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

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

Ftp客户端

开发平台：

Unix_Linux

support.c：源码内容
  1. /*
  2.  * ProFTPD - FTP server daemon
  3.  * Copyright (c) 1997, 1998 Public Flood Software
  4.  *  
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
  18.  */
  20. /* Various basic support routines for ProFTPD, used by all modules
  21.  * and not specific to one or another.
  22.  * $Id: support.c,v 1.9 1999/10/01 23:52:38 macgyver Exp $
  23.  */
  25. /* History Log:
  26.  * 10/29/97 current: 0.99.0pl9, next: 0.99.0pl10
  27.  *   Added get_fs_size(), used to determine the amount of space
  28.  *   available on a filesystem (if supported)
  29.  *
  30.  * 7/9/97 current: 0.99.0pl6, next: 0.99.0pl7
  31.  *   Added exit handler chain, works identically to libc atexit(),
  32.  *   however atexit() can't be used because proftpd often terminates
  33.  *   with _exit() rather than exit().
  34.  *
  35.  * 5/12/97 current: 0.99.0pl1, next: 0.99.0pl2
  36.  *   Added check_shutmsg function which checks for the existance
  37.  *   of the shutdown file, and returns timing information
  38.  *   about an impending shutdown.  Also added, str_interpolate,
  39.  *   to interpolate custom "%x" metas.
  40.  *
  41.  * 4/30/97 current: 0.99.0pl1, next: 0.99.0pl2
  42.  *   Fixed bug in dir_interpolate that was not 0-terminating
  43.  *   all strings.
  44.  *
  45.  * 4/24/97 current: 0.99.0pl1, next: 0.99.0pl2
  46.  *   Oops... forgot to check for empty username in dir_interpolate(),
  47.  *   so commands like "cd ~" aren't working.
  48.  *   Status: Fixed.
  49.  *
  50.  * 4/25/97 current: 0.99.0pl1, next: 0.99.0pl2
  51.  *   Added schedule() and run_schedule() to allow async routines
  52.  *   (called from an alarm or inside the _ioreq_service() to
  53.  *   schedule a function to run after the next `n' loops)
  54.  *   The function (run_schedule() is called from io.c) will
  55.  *   run at an "undetermined" later time (async), when
  56.  *   no I/O is in progress (basically, allowing the schedule
  57.  *   of a "low priority" function.  The higher the loop count
  58.  *   (via nloops), the later it will run.
  59.  */
  61. #include "conf.h"
  63. #include <signal.h>
  65. #ifdef HAVE_SYS_STATVFS_H
  66. # include <sys/statvfs.h>
  67. #elif defined(HAVE_SYS_VFS_H)
  68. # include <sys/vfs.h>
  69. #endif
  71. #ifdef AIX3
  72. #include <sys/statfs.h>
  73. #endif
  75. typedef struct _exithandler {
  76.   struct _exithandler *next,*prev;
  78.   void (*f)();
  79. } exithandler_t;
  81. typedef struct _sched {
  82.   struct _sched *next,*prev;
  84.   void (*f)(void*,void*,void*,void*);
  85.   int loops;
  86.   void *a1,*a2,*a3,*a4;
  87. } sched_t;
  89. static xaset_t *scheds = NULL;
  90. static xaset_t *exits = NULL;
  92. /* performs "hard block" of all important signals (as opposed to 
  93.  * block_alarms) */
  94. static void _block_signals(int block)
  95. {
  96.   static sigset_t sigset;
  98.   if(block) {
  99.     sigemptyset(&sigset);
  101.     sigaddset(&sigset,SIGTERM);
  102.     sigaddset(&sigset,SIGCHLD);
  103.     sigaddset(&sigset,SIGUSR1);
  104.     sigaddset(&sigset,SIGINT);
  105.     sigaddset(&sigset,SIGQUIT);
  106.     sigaddset(&sigset,SIGALRM);
  107.     sigaddset(&sigset,SIGIO);
  108. #ifdef SIGBUS
  109.     sigaddset(&sigset,SIGBUS);
  110. #endif
  111.     sigaddset(&sigset,SIGHUP);
  113.     sigprocmask(SIG_BLOCK,&sigset,NULL);
  114.   } else
  115.     sigprocmask(SIG_UNBLOCK,&sigset,NULL);
  116. }
  118. void block_signals()
  119. {
  120.   _block_signals(1);
  121. }
  123. void unblock_signals()
  124. {
  125.   _block_signals(0);
  126. }
  128. void add_exit_handler(void (*f)())
  129. {
  130.   exithandler_t *e;
  132.   if(!exits)
  133.     exits = xaset_create(permanent_pool,NULL);
  135.   e = pcalloc(permanent_pool,sizeof(exithandler_t));
  136.   e->f = f;
  137.   xaset_insert(exits,(xasetmember_t*)e);
  138. }
  140. void run_exit_handlers()
  141. {
  142.   exithandler_t *e;
  144.   if(!exits)
  145.     return;
  147.   for(e = (exithandler_t*)exits->xas_list; e; e=e->next)
  148.     e->f();
  149. }
  151. void schedule(void (*f)(void*,void*,void*,void*),int nloops,
  152.               void *a1, void *a2, void *a3, void *a4)
  153. {
  154.   pool *p;
  155.   sched_t *s;
  157.   if(!scheds) {
  158.    p = make_sub_pool(permanent_pool);
  159.    scheds = xaset_create(p,NULL);
  160.   } else
  161.    p = scheds->mempool;
  163.   s = (sched_t*)pcalloc(p,sizeof(sched_t));
  164.   s->f = f;
  165.   s->a1 = a1;
  166.   s->a2 = a2;
  167.   s->a3 = a3;
  168.   s->a4 = a4;
  169.   s->loops = nloops;
  170.   xaset_insert(scheds,(xasetmember_t*)s);
  171. }
  173. void run_schedule()
  174. {
  175.   sched_t *s,*snext;
  177.   handle_sig_alarm();
  178.   if(!scheds || !scheds->xas_list)
  179.     return;
  181.   for(s = (sched_t*)scheds->xas_list; s; s=snext) {
  182.     snext = s->next;
  184.     if(s->loops-- <= 0) {
  185.       s->f(s->a1,s->a2,s->a3,s->a4);
  186.       xaset_remove(scheds,(xasetmember_t*)s);
  187.     }
  188.   }
  189. }
  191. /* Returns TRUE if there is a scheduled function waiting */
  192. int schedulep()
  193. {
  194.   handle_sig_alarm();
  195.   return (scheds && scheds->xas_list);
  196. }
  198. /* Interpolates a pathname, expanding ~ notation if necessary
  199.  */
  201. char *dir_interpolate(pool *p, const char *path)
  202. {
  203.   struct passwd *pw;
  204.   char *user,*tmp;
  205.   char *ret = (char*)path;
  207.   if(!ret)
  208.     return NULL;
  210.   if(*ret == '~') {
  211.     user = pstrdup(p,ret+1);
  212.     tmp = index(user,'/');
  214.     if(tmp)
  215.       *tmp++ = '';
  217.     if(!*user)
  218.       user = session.user;
  220.     pw = auth_getpwnam(p,user);
  222.     if(!pw) {
  223.       errno = ENOENT;
  224.       return NULL;
  225.     }
  227.     ret = pdircat(p,pw->pw_dir,tmp,NULL);
  228.   }
  230.   return ret;
  231. }
  233. /* dir_best_path() creates the "most" fully canonicalized path possible
  234.  * (i.e. if path components at the end don't exist, they are ignored
  235.  */
  237. char *dir_best_path(pool *p, const char *path)
  238. {
  239.   char workpath[MAXPATHLEN];
  240.   char realpath[MAXPATHLEN];
  241.   char *target = NULL, *ntarget;
  242.   int fini = 0;
  244.   if(*path == '~') {
  245.     if(fs_interpolate(path,workpath,MAXPATHLEN) == -1)
  246.       fs_dircat(workpath,sizeof(workpath),fs_getcwd(),path);
  247.   } else {
  248.     fs_dircat(workpath,sizeof(workpath),fs_getcwd(),path);
  249.   }
  251.   fs_clean_path(pstrdup(p,workpath),workpath,MAXPATHLEN);
  253.   while(!fini && workpath[0]) {
  254.     if(fs_resolve_path(workpath,realpath,MAXPATHLEN,0) != -1)
  255.       break;
  256.   
  257.     ntarget = rindex(workpath,'/');
  258.     if(ntarget) {
  259.       if(target)
  260.         fs_dircat(workpath,sizeof(workpath),workpath,target);
  262.       target = ntarget;
  263.       *target++ = '';
  264.     } else
  265.       fini++;
  266.   }
  268.   if(!fini && workpath[0]) {
  269.     if(target)
  270.       fs_dircat(workpath,sizeof(workpath),realpath,target);
  271.     else
  272.       sstrncpy(workpath,realpath,sizeof(workpath));
  273.   } else
  274.     fs_dircat(workpath,sizeof(workpath),"/",target);
  276.   return pstrdup(p,workpath);
  277. }
  279. char *dir_canonical_path(pool *p, const char *path)
  280. {
  281.   char buf[MAXPATHLEN];
  282.   char work[MAXPATHLEN];
  284.   if(*path == '~') {
  285.     if(fs_interpolate(path,work,MAXPATHLEN) == -1)
  286.       fs_dircat(work, sizeof(work), fs_getcwd(), path);
  287.   } else {
  288.     fs_dircat(work, sizeof(work), fs_getcwd(), path);
  289.   }
  290.   
  291.   fs_clean_path(work, buf, MAXPATHLEN);
  292.   return pstrdup(p, buf);
  293. }
  295. /* dir_realpath() is needed to properly dereference symlinks (getcwd() may
  296.  * not work if permissions cause problems somewhere up the tree).
  297.  */
  299. char *dir_realpath(pool *p, const char *path)
  300. {
  301.   char buf[MAXPATHLEN];
  303.   if(fs_resolve_partial(path,buf,MAXPATHLEN,0) == -1)
  304.     return NULL;
  306.   return pstrdup(p,buf);
  307. }
  309. char *dir_virtual_chdir(pool *p, const char *path)
  310. {
  311.   char buf[MAXPATHLEN];
  312.   char work[MAXPATHLEN];
  314.   if(*path == '~') {
  315.     if(fs_interpolate(path,work,MAXPATHLEN) == -1)
  316.       fs_dircat(work,sizeof(work),fs_getvwd(),path);
  317.   } else
  318.     fs_dircat(work,sizeof(work),fs_getvwd(),path);
  320.   fs_clean_path(work,buf,MAXPATHLEN);
  321.   return pstrdup(p,buf);
  322. }
  324. /* Takes a directory and returns it's absolute version.  ~username
  325.  * references are appropriately interpolated.  "Absolute" includes
  326.  * a *full* reference based on the root directory, not upon a chrooted
  327.  * dir.
  328.  */
  330. char *dir_abs_path(pool *p, const char *path, int interpolate)
  331. {
  332.   char *res = NULL;
  334.   if(interpolate)
  335.     path = dir_interpolate(p,path);
  336.   
  337.   if(!path)
  338.     return NULL;  
  339.     
  340.   if(*path != '/') {
  341.     if(session.anon_root)
  342.       res = pdircat(p,session.anon_root,fs_getcwd(),path,NULL);
  343.     else
  344.       res = pdircat(p,fs_getcwd(),path,NULL);
  345.   } else if(session.anon_root)
  346.     res = pdircat(p,session.anon_root,path,NULL);
  347.   else
  348.     res = pstrdup(p,path);
  350.   return res;
  351. }
  353. static mode_t _symlink(char *path, ino_t last_inode, int rcount)
  354. {
  355.   char buf[255];
  356.   struct stat sbuf;
  358.   if(++rcount >= 32) {
  359.     errno = ELOOP;
  360.     return 0;
  361.   }
  363.   bzero(buf,sizeof(buf));
  365.   if(fs_readlink(path,buf,sizeof(buf)) == -1)
  366.     return (mode_t)0;
  368.   if(fs_lstat(buf,&sbuf) != -1) {
  369.     if(sbuf.st_ino && (ino_t)sbuf.st_ino == last_inode) {
  370.       errno = ELOOP;
  371.       return 0;
  372.     }
  374.     if(S_ISLNK(sbuf.st_mode))
  375.       return _symlink(buf,(ino_t)sbuf.st_ino,rcount);
  376.     return sbuf.st_mode;
  377.   }
  379.   return 0;
  380. }
  382. mode_t file_mode(char *path)
  383. {
  384.   struct stat sbuf;
  385.   mode_t res = 0;
  387.   if(fs_stat(path,&sbuf) != -1) {
  388.     if(S_ISLNK(sbuf.st_mode))
  389.       res = _symlink(path,(ino_t)0,0);
  390.     else
  391.       res = sbuf.st_mode;
  392.   }
  394.   return res;
  395. }
  397. /* dirp == -1, don't care if file or directory */
  399. static int _exists(char *path, int dirp)
  400. {
  401.   mode_t fmode;
  403.   if((fmode = file_mode(path)) != 0) {
  404.     if(dirp == 1 && !S_ISDIR(fmode))
  405.       return FALSE;
  406.     else if(dirp == 0 && S_ISDIR(fmode))
  407.       return FALSE;
  408.     return TRUE;
  409.   }
  411.   return FALSE;
  412. }
  414. int file_exists(char *path)
  415. {
  416.   return _exists(path,0);
  417. }
  419. int dir_exists(char *path)
  420. {
  421.   return _exists(path,1);
  422. }
  424. int exists(char *path)
  425. {
  426.   return _exists(path,-1);
  427. }
  429. char *strip_end(char *s, char *ch)
  430. {
  431.   int i = strlen(s);
  433.   while(i && strchr(ch,*(s+i-1))) {
  434.     *(s+i-1) = '';
  435.     i--;
  436.   }
  438.   return s;
  439. }
  441. /* get_token tokenizes a string, increments the src pointer to
  442.  * the next non-separator in the string.  If the src string is
  443.  * empty or NULL, the next token returned is NULL.
  444.  */
  446. char *get_token(char **s, char *sep)
  447. {
  448.   char *res;
  450.   if(!s || !*s || !**s)
  451.     return NULL;
  453.   res = *s;
  455.   while(**s && !strchr(sep,**s)) (*s)++;
  457.   if(**s) {
  458.     *(*s)++ = '';
  459.   }
  461.   return res;
  462. }
  464. /* safe_token tokenizes a string, and increments the pointer to
  465.  * the next non-white space character.  It's "safe" because it
  466.  * never returns NULL, only an empty string if no token remains
  467.  * in the source string.
  468.  */
  470. char *safe_token(char **s)
  471. {
  472.   char *res = "";
  474.   if(!s || !*s)
  475.     return res;
  477.   while(isspace((UCHAR)**s) && **s) (*s)++;
  479.   if(**s) {
  480.     res = *s;
  482.     while(!isspace((UCHAR)**s) && **s) (*s)++;
  484.     if(**s)
  485.       *(*s)++ = '';
  487.     while(isspace((UCHAR)**s) && **s) (*s)++;
  488.   }
  490.   return res;
  491. }
  493. /* Checks for the existance of SHUTMSG_PATH.  deny and disc are
  494.  * filled with the times to deny new connections and disconnect
  495.  * existing ones.
  496.  */
  498. int check_shutmsg(time_t *shut, time_t *deny, time_t *disc, char *msg, 
  499.                   size_t msg_size)
  500. {
  501.   FILE *fp;
  502.   char *deny_str,*disc_str,*cp,buf[1025];
  503.   char hr[3],mn[3];
  504.   time_t now,shuttime = (time_t)0;
  505.   struct tm tm;
  507.   if(file_exists(SHUTMSG_PATH) && (fp = fopen(SHUTMSG_PATH,"r"))) {
  508.     if((cp = fgets(buf,sizeof(buf),fp)) != NULL) {
  509.       buf[1024] = ''; CHOP(cp);
  511.       /* We use this to fill in dst, timezone, etc */
  512.       time(&now);
  513.       tm = *(localtime(&now));
  515.       tm.tm_year = atoi(safe_token(&cp)) % 100;
  516.       tm.tm_mon = atoi(safe_token(&cp));
  517.       tm.tm_mday = atoi(safe_token(&cp));
  518.       tm.tm_hour = atoi(safe_token(&cp));
  519.       tm.tm_min = atoi(safe_token(&cp));
  520.       tm.tm_sec = atoi(safe_token(&cp));
  522.       deny_str = safe_token(&cp);
  523.       disc_str = safe_token(&cp);
  525.       if((shuttime = mktime(&tm)) == (time_t)-1) {
  526.         fclose(fp);
  527.         return 0;
  528.       }
  530.       if(deny) {
  531.         if(strlen(deny_str) == 4) {
  532.           sstrncpy(hr,deny_str,sizeof(hr)); hr[2] = ''; deny_str += 2;
  533.           sstrncpy(mn,deny_str,sizeof(mn)); mn[2] = '';
  534.           
  535.           *deny = shuttime - ((atoi(hr) * 3600) + (atoi(mn) * 60));
  536.         } else
  537.           *deny = shuttime;
  538.       }
  540.       if(disc) {
  541.         if(strlen(disc_str) == 4) {
  542.           sstrncpy(hr,disc_str,sizeof(hr)); hr[2] = ''; disc_str += 2;
  543.           sstrncpy(mn,disc_str,sizeof(mn)); mn[2] = '';
  545.           *disc = shuttime - ((atoi(hr) * 3600) + (atoi(mn) * 60));
  546.         } else
  547.           *disc = shuttime;
  548.       }
  550.       if(fgets(buf,sizeof(buf),fp) && msg) {
  551.         buf[255] = '';
  552. CHOP(buf);
  553.         sstrncpy(msg,buf,msg_size-1);
  554.       }
  555.     }
  557.     fclose(fp);
  558.     if(shut)
  559.       *shut = shuttime;
  560.     return 1;
  561.   }
  563.   return 0;
  564. }
  566. char *make_arg_str(pool *p,int argc,char **argv)
  567. {
  568.   char *res = "";
  570.   while(argc--)
  571.     if(*res)
  572.       res = pstrcat(p,res," ",*argv++,NULL);
  573.     else
  574.       res = pstrcat(p,res,*argv++,NULL);
  576.   return res;
  577. }
  579. char *sreplace(pool *p, char *s, ...)
  580. {
  581.   va_list args;
  582.   char *m,*r,*src = s,*cp;
  583.   char **mptr,**rptr;
  584.   char *marr[33],*rarr[33];
  585.   char buf[2048];
  586.   int mlen = 0,rlen = 0;
  588.   cp = buf;
  589.   *cp = '';
  590.   
  591.   bzero(marr,sizeof(marr));
  593.   va_start(args,s);
  595.   while((m = va_arg(args,char*)) != NULL && mlen < 32) {
  596.     if((r = va_arg(args,char*)) == NULL)
  597.       break;
  599.     marr[mlen] = m;
  600.     rarr[mlen++] = r;
  601.   }
  603.   va_end(args);
  605.   while(*src) {
  606.     for(mptr = marr, rptr = rarr; *mptr; mptr++, rptr++) {
  607.       mlen = strlen(*mptr);
  608.       rlen = strlen(*rptr);
  610.       if(strncmp(src,*mptr,mlen) == 0) {
  611.         sstrncpy(cp,*rptr,sizeof(buf) - strlen(buf));
  612. if(((cp + rlen) - buf + 1) > sizeof(buf)) {
  613.   log_pri(LOG_ERR,
  614.   "Warning, attempt to overflow internal ProFTPD buffers.");
  615.   cp = buf + sizeof(buf) - 1;
  616.   goto done;
  617. } else {
  618.   cp += rlen;
  619. }
  621.         src += mlen;
  622.         break;
  623.       }
  624.     }
  625.     
  626.     if(!*mptr) {
  627.       if((cp - buf + 1) > sizeof(buf)) {
  628. log_pri(LOG_ERR,
  629. "Warning, attempt to overflow internal ProFTPD buffers.");
  630. cp = buf + sizeof(buf) - 1;
  631.       }
  632.       *cp++ = *src++;
  633.     }
  634.   }
  635.   
  636.  done:
  637.   *cp = '';
  639.   return pstrdup(p,buf);
  640. }
  642. /* Simple multiplication & division doesn't work with very large
  643.  * filesystems (overflows 32 bits).  This code should handle it.
  644.  */
  646. static
  647. unsigned long _calc_fs(unsigned long blocks, unsigned long bsize)
  648. {
  649.   unsigned long bl_lo,bl_hi;
  650.   unsigned long res_lo,res_hi,tmp;
  652.   bl_lo = blocks & 0x0000ffff;
  653.   bl_hi = blocks & 0xffff0000;
  655.   tmp = (bl_hi >> 16) * bsize;
  656.   res_hi = tmp & 0xffff0000;
  657.   res_lo = (tmp & 0x0000ffff) << 16;
  658.   res_lo += bl_lo * bsize;
  660.   if(res_hi & 0xfc000000) /* overflow */
  661. return 0;
  663.   return (res_lo >> 10) | (res_hi << 6);
  664. }
  666. #ifdef HAVE_SYS_STATVFS_H
  667. unsigned long get_fs_size(char *s)
  668. {
  669.   struct statvfs vfs;
  671.   if(statvfs(s,&vfs) != 0)
  672.     return 0;
  674.   return _calc_fs(vfs.f_bavail,vfs.f_bsize);
  675. }
  676. #elif defined(HAVE_SYS_VFS_H)
  677. unsigned long get_fs_size(char *s)
  678. {
  679.   struct statfs vfs;
  681.   if(statfs(s,&vfs) != 0)
  682.     return 0;
  684.   return _calc_fs(vfs.f_bavail,vfs.f_bsize);
  685. }
  686. #endif /* HAVE_SYS_STATVFS/HAVE_SYS_VFS */
  688. /* "safe" strcat, saves room for  at end of dest, and refuses to copy
  689.  * more than "n" bytes.
  690.  */
  692. char *sstrcat(char *dest, const char *src, size_t n) {
  693.   register char *d;
  694.   
  695.   for(d = dest; *d && n > 1; d++, n--) ;
  696.   
  697.   while(n-- > 1 && *src)
  698.     *d++ = *src++;
  699.   
  700.   *d = 0;
  701.   return dest;
  702. }
  704. /* "safe" strncpy, saves room for  at end of dest, and refuses to copy
  705.  * more than "n" bytes.
  706.  */
  707. char *sstrncpy(char *dest, const char *src, size_t n) {
  708.   register char *d;
  709.   
  710.   if(!dest || !src)
  711.     return NULL;
  712.   
  713.   for(d = dest; *src && n > 1; n--)
  714.     *d++ = *src++;
  715.   
  716.   *d = 0;
  717.   
  718.   return dest;
  719. }