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

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

Ftp客户端

开发平台：

Unix_Linux

extensions.c：源码内容
  1. /****************************************************************************  
  2.  
  3.   Copyright (c) 1999 WU-FTPD Development Group.  
  4.   All rights reserved.
  5.   
  6.   Portions Copyright (c) 1980, 1985, 1988, 1989, 1990, 1991, 1993, 1994
  7.     The Regents of the University of California.
  8.   Portions Copyright (c) 1993, 1994 Washington University in Saint Louis.
  9.   Portions Copyright (c) 1996, 1998 Berkeley Software Design, Inc.
  10.   Portions Copyright (c) 1989 Massachusetts Institute of Technology.
  11.   Portions Copyright (c) 1998 Sendmail, Inc.
  12.   Portions Copyright (c) 1983, 1995, 1996, 1997 Eric P.  Allman.
  13.   Portions Copyright (c) 1997 by Stan Barber.
  14.   Portions Copyright (c) 1997 by Kent Landfield.
  15.   Portions Copyright (c) 1991, 1992, 1993, 1994, 1995, 1996, 1997
  16.     Free Software Foundation, Inc.  
  17.  
  18.   Use and distribution of this software and its source code are governed 
  19.   by the terms and conditions of the WU-FTPD Software License ("LICENSE").
  20.  
  21.   If you did not receive a copy of the license, it may be obtained online
  22.   at http://www.wu-ftpd.org/license.html.
  23.  
  24.   $Id: extensions.c,v 1.46 1999/10/14 14:36:52 wuftpd Exp $
  25.  
  26. ****************************************************************************/
  27. #include "config.h"
  29. #include <stdio.h>
  30. #include <errno.h>
  31. #include <string.h>
  33. #ifdef HAVE_SYS_SYSLOG_H
  34. #include <sys/syslog.h>
  35. #elif defined(HAVE_SYSLOG_H) || !defined(AUTOCONF)
  36. #include <syslog.h>
  37. #endif
  39. #ifdef TIME_WITH_SYS_TIME
  40. #include <time.h>
  41. #include <sys/time.h>
  42. #else
  43. #ifdef HAVE_SYS_TIME_H
  44. #include <sys/time.h>
  45. #else
  46. #include <time.h>
  47. #endif
  48. #endif
  49. #include <pwd.h>
  50. #include <setjmp.h>
  51. #include <grp.h>
  53. #include <sys/types.h>
  54. #include <sys/stat.h>
  55. #include <sys/file.h>
  56. #include <sys/param.h>
  58. #ifdef HAVE_SYS_FS_UFS_QUOTA_H
  59. #include <sys/fs/ufs_quota.h>
  60. #elif defined(HAVE_UFS_UFS_QUOTA_H)
  61. #include <ufs/ufs/quota.h>
  62. #elif defined(HAVE_UFS_QUOTA_H)
  63. #include <ufs/quota.h>
  64. #elif defined(HAVE_SYS_MNTENT_H)
  65. #include <sys/mntent.h>
  66. #elif defined(HAVE_SYS_MNTTAB_H)
  67. #include <sys/mnttab.h>
  68. #endif
  70. #if defined(HAVE_STATVFS)
  71. #include <sys/statvfs.h>
  72. #elif defined(HAVE_SYS_VFS)
  73. #include <sys/vfs.h>
  74. #elif defined(HAVE_SYS_MOUNT)
  75. #include <sys/mount.h>
  76. #endif
  78. #include "../support/ftp.h"
  80. #ifdef HAVE_PATHS_H
  81. #include <paths.h>
  82. #endif
  83. #include "pathnames.h"
  84. #include "extensions.h"
  85. #include "wu_fnmatch.h"
  86. #include "proto.h"
  88. #if defined(HAVE_FTW)
  89. #include <ftw.h>
  90. #else
  91. #include "support/ftw.h"
  92. #endif
  94. #ifdef QUOTA
  95. struct dqblk quota;
  96. char *time_quota(long curstate, long softlimit, long timelimit, char *timeleft);
  97. #endif
  99. #ifdef HAVE_REGEX_H
  100. #include <regex.h>
  101. #endif
  103. #if defined(HAVE_REGEX) && defined(SVR4) && ! (defined(NO_LIBGEN))
  104. #include <libgen.h>
  105. #endif
  107. extern int type, transflag, ftwflag, authenticated, autospout_free, data,
  108.     pdata, anonymous, guest;
  110. #ifdef LOG_FAILED
  111. extern char the_user[];
  112. #endif
  114. extern char *globerr, remotehost[];
  115. #ifdef THROUGHPUT
  116. extern char remoteaddr[];
  117. #endif
  119. #ifndef HAVE_REGEX
  120. char *re_comp(const char *regex);
  121. int re_exec(const char *p1);
  122. #endif
  124. char shuttime[30], denytime[30], disctime[30];
  126. FILE *dout;
  128. time_t newer_time;
  130. int show_fullinfo;
  132. /* This always was a bug, because neither st_size nor time_t were required to
  133.    be compatible with int, but needs fixing properly for C9X. */
  135. /* Some systems use one format, some another.  This takes care of the garbage */
  136. /* Do the system specific stuff only if we aren't autoconfed */
  137. #if !defined(L_FORMAT)
  138. #if (defined(BSD) && (BSD >= 199103)) && !defined(LONGOFF_T)
  139. #define L_FORMAT "qd"
  140. #else
  141. #define L_FORMAT "d"
  142. #endif
  143. #endif
  144. #if !defined(T_FORMAT)
  145. #define T_FORMAT "d"
  146. #endif
  147. #if !defined(PW_UID_FORMAT)
  148. #define PW_UID_FORMAT "d"
  149. #endif
  150. #if !defined(GR_GID_FORMAT)
  151. #define GR_GID_FORMAT "d"
  152. #endif
  154. int snprintf(char *str, size_t count, const char *fmt,...);
  156. int check_newer(char *path, struct stat *st, int flag)
  157. {
  158.     if (st->st_mtime > newer_time) {
  159. if (show_fullinfo != 0) {
  160.     if (flag == FTW_F || flag == FTW_D) {
  161. fprintf(dout, "%s %" L_FORMAT " %" T_FORMAT " %sn",
  162. flag == FTW_F ? "F" : "D",
  163. st->st_size, st->st_mtime, path);
  164.     }
  165. }
  166. else if (flag == FTW_F)
  167.     fprintf(dout, "%sn", path);
  168.     }
  170.     /* When an ABOR has been received (which sets ftwflag > 1) return a
  171.      * non-zero value which causes ftw to stop tree traversal and return. 
  172.      */
  174.     return (ftwflag > 1 ? 1 : 0);
  175. }
  177. #if defined(HAVE_STATVFS)
  178. long getSize(char *s)
  179. {
  180.     int c;
  181.     struct statvfs buf;
  183.     if ((c = statvfs(s, &buf)) != 0)
  184. return (0);
  186.     return (buf.f_bavail * buf.f_frsize / 1024);
  187. }
  188. #elif defined(HAVE_SYS_VFS) || defined (HAVE_SYS_MOUNT)
  189. long getSize(char *s)
  190. {
  191.     int c;
  192.     struct statfs buf;
  194.     if ((c = statfs(s, &buf)) != 0)
  195. return (0);
  197.     return (buf.f_bavail * buf.f_bsize / 1024);
  198. }
  199. #endif
  201. /*************************************************************************/
  202. /* FUNCTION  : msg_massage                                               */
  203. /* PURPOSE   : Scan a message line for magic cookies, replacing them as  */
  204. /*             needed.                                                   */
  205. /* ARGUMENTS : pointer input and output buffers                          */
  206. /*************************************************************************/
  208. void msg_massage(const char *inbuf, char *outbuf, size_t outlen)
  209. {
  210.     const char *inptr = inbuf;
  211.     char *outptr = outbuf;
  212. #ifdef QUOTA
  213.     char timeleft[80];
  214. #endif
  215.     char buffer[MAXPATHLEN];
  216.     time_t curtime;
  217.     int limit;
  218. #ifndef LOG_FAILED
  219.     extern struct passwd *pw;
  220. #endif
  221.     struct aclmember *entry;
  223. #ifdef VIRTUAL
  224.     extern int virtual_mode;
  225.     extern int virtual_ftpaccess;
  226.     extern char virtual_email[];
  227. #endif
  228.     extern char hostname[];
  229.     extern char authuser[];
  231.     (void) acl_getclass(buffer);
  232.     limit = acl_getlimit(buffer, NULL);
  234.     while ((outlen > 1) && (*inptr != '')) {
  235. if (*inptr != '%') {
  236.     *outptr++ = *inptr;
  237.     outlen -= 1;
  238. }
  239. else {
  240.     entry = NULL;
  241.     switch (*++inptr) {
  242.     case 'E':
  243. #ifdef VIRTUAL
  244. if (virtual_mode && !virtual_ftpaccess && virtual_email[0] != '')
  245.     snprintf(outptr, outlen, "%s", virtual_email);
  246. else
  247. #endif
  248. if ((getaclentry("email", &entry)) && ARG0)
  249.     snprintf(outptr, outlen, "%s", ARG0);
  250. else
  251.     *outptr = '';
  252. break;
  254.     case 'N':
  255. snprintf(outptr, outlen, "%d", acl_countusers(buffer));
  256. break;
  258.     case 'M':
  259. if (limit == -1)
  260.     strncpy(outptr, "unlimited", outlen);
  261. else
  262.     snprintf(outptr, outlen, "%d", limit);
  263. break;
  265.     case 'T':
  266. (void) time(&curtime);
  267. strncpy(outptr, ctime(&curtime), outlen);
  268. if (outlen > 24)
  269.     *(outptr + 24) = '';
  270. break;
  272.     case 'F':
  273. #if defined(HAVE_STATVFS) || defined(HAVE_SYS_VFS) || defined(HAVE_SYS_MOUNT)
  274. snprintf(outptr, outlen, "%lu", (long) getSize("."));
  275. #else
  276. *outptr = '';
  277. #endif
  278. break;
  280.     case 'C':
  281. #ifdef HAVE_GETCWD
  282. (void) getcwd(outptr, outlen);
  283. #else
  284. #error wu-ftpd on this platform has security deficiencies!!!
  285. (void) getwd(outptr);
  286. #endif
  287. break;
  289.     case 'R':
  290. strncpy(outptr, remotehost, outlen);
  291. break;
  293.     case 'L':
  294. strncpy(outptr, hostname, outlen);
  295. break;
  297.     case 'U':
  298. #ifdef LOG_FAILED
  299. strncpy(outptr, the_user, outlen);
  300. #else /* LOG_FAILED */
  301. strncpy(outptr,
  302. (pw == NULL) ? "[unknown]" : pw->pw_name, outlen);
  303. #endif /* LOG_FAILED */
  304. break;
  306.     case 's':
  307. strncpy(outptr, shuttime, outlen);
  308. if (outlen > 24)
  309.     *(outptr + 24) = '';
  310. break;
  312.     case 'd':
  313. strncpy(outptr, disctime, outlen);
  314. if (outlen > 24)
  315.     *(outptr + 24) = '';
  316. break;
  318.     case 'r':
  319. strncpy(outptr, denytime, outlen);
  320. if (outlen > 24)
  321.     *(outptr + 24) = '';
  322. break;
  324. /* KH : cookie %u for RFC931 name */
  325.     case 'u':
  326. if (authenticated)
  327.     strncpy(outptr, authuser, outlen);
  328. else
  329.     strncpy(outptr, "[unknown]", outlen);
  330. break;
  332. #ifdef QUOTA
  333.     case 'B':
  334. #ifdef QUOTA_BLOCKS /* 1024-blocks instead of 512-blocks */
  335. snprintf(outptr, outlen, "%ld", quota.dqb_bhardlimit % 2 ?
  336.  (long) (quota.dqb_bhardlimit / 2 + 1) : (long) (quota.dqb_bhardlimit / 2));
  337. #else
  338. snprintf(outptr, outlen, "%ld", (long) quota.dqb_bhardlimit);
  339. #endif
  340. break;
  342.     case 'b':
  343. #ifdef QUOTA_BLOCKS /* 1024-blocks instead of 512-blocks */
  344. snprintf(outptr, outlen, "%ld", quota.dqb_bsoftlimit % 2 ?
  345.  (long) (quota.dqb_bsoftlimit / 2 + 1) : (long) (quota.dqb_bsoftlimit / 2));
  346. #else
  347. snprintf(outptr, outlen, "%ld", (long) quota.dqb_bsoftlimit);
  348. #endif
  349. break;
  351.     case 'Q':
  352. #ifdef QUOTA_BLOCKS /* 1024-blocks instead of 512-blocks */
  353. snprintf(outptr, outlen, "%ld", quota.dqb_curblocks % 2 ?
  354.  (long) (quota.dqb_curblocks / 2 + 1) : (long) (quota.dqb_curblocks / 2));
  355. #else
  356. snprintf(outptr, outlen, "%ld", quota.dqb_curblocks);
  357. #endif
  358. break;
  360.     case 'I':
  361. #if defined(QUOTA_INODE)
  362. snprintf(outptr, outlen, "%d", quota.dqb_ihardlimit);
  363. #else
  364. snprintf(outptr, outlen, "%ld", (long) quota.dqb_fhardlimit);
  365. #endif
  366. break;
  368.     case 'i':
  369. #if defined(QUOTA_INODE)
  370. snprintf(outptr, outlen, "%d", quota.dqb_isoftlimit);
  371. #else
  372. snprintf(outptr, outlen, "%ld", (long) quota.dqb_fsoftlimit);
  373. #endif
  374. break;
  376.     case 'q':
  377. #if defined(QUOTA_INODE)
  378. snprintf(outptr, outlen, "%d", quota.dqb_curinodes);
  379. #else
  380. snprintf(outptr, outlen, "%ld", (long) quota.dqb_curfiles);
  381. #endif
  382. break;
  384.     case 'H':
  385. time_quota(quota.dqb_curblocks, quota.dqb_bsoftlimit,
  386. #if defined(QUOTA_INODE)
  387.    quota.dqb_btime, timeleft);
  388. #else
  389.    quota.dqb_btimelimit, timeleft);
  390. #endif
  391. strncpy(outptr, timeleft, outlen);
  392. break;
  394.     case 'h':
  395. #if defined(QUOTA_INODE)
  396. time_quota(quota.dqb_curinodes, quota.dqb_isoftlimit,
  397.    quota.dqb_itime, timeleft);
  398. #else
  399. time_quota(quota.dqb_curfiles, quota.dqb_fsoftlimit,
  400.    quota.dqb_ftimelimit, timeleft);
  401. #endif
  402. strncpy(outptr, timeleft, outlen);
  403. break;
  404. #endif /* QUOTA */
  406.     case '%':
  407. *outptr++ = '%';
  408. outlen -= 1;
  409. *outptr = '';
  410. break;
  412.     default:
  413. *outptr++ = '%';
  414. outlen -= 1;
  415. if (outlen > 1) {
  416.     *outptr++ = *inptr;
  417.     outlen -= 1;
  418. }
  419. *outptr = '';
  420. break;
  421.     }
  422.     outptr[outlen - 1] = '';
  423.     while (*outptr) {
  424. outptr++;
  425. outlen -= 1;
  426.     }
  427. }
  428. inptr++;
  429.     }
  430.     if (outlen > 0)
  431. *outptr = '';
  432. }
  434. /*************************************************************************/
  435. /* FUNCTION  : cwd_beenhere                                              */
  436. /* PURPOSE   : Return 1 if the user has already visited this directory   */
  437. /*             via C_WD.                                                 */
  438. /* ARGUMENTS : a power-of-two directory function code (README, MESSAGE)  */
  439. /*************************************************************************/
  441. int cwd_beenhere(int dircode)
  442. {
  443.     struct dirlist {
  444. struct dirlist *next;
  445. int dircode;
  446. char dirname[1];
  447.     };
  449.     static struct dirlist *head = NULL;
  450.     struct dirlist *curptr;
  451.     char cwd[MAXPATHLEN];
  453.     (void) fb_realpath(".", cwd);
  455.     for (curptr = head; curptr != NULL; curptr = curptr->next)
  456. if (strcmp(curptr->dirname, cwd) == 0) {
  457.     if (!(curptr->dircode & dircode)) {
  458. curptr->dircode |= dircode;
  459. return (0);
  460.     }
  461.     return (1);
  462. }
  463.     curptr = (struct dirlist *) malloc(strlen(cwd) + 1 + sizeof(struct dirlist));
  465.     if (curptr != NULL) {
  466. curptr->next = head;
  467. head = curptr;
  468. curptr->dircode = dircode;
  469. strcpy(curptr->dirname, cwd);
  470.     }
  471.     return (0);
  472. }
  474. /*************************************************************************/
  475. /* FUNCTION  : show_banner                                               */
  476. /* PURPOSE   : Display a banner on the user's terminal before login      */
  477. /* ARGUMENTS : reply code to use                                         */
  478. /*************************************************************************/
  480. void show_banner(int msgcode)
  481. {
  482.     char *crptr, linebuf[1024], outbuf[1024];
  483.     struct aclmember *entry = NULL;
  484.     FILE *infile;
  486. #ifdef VIRTUAL
  487.     extern int virtual_mode;
  488.     extern int virtual_ftpaccess;
  489.     extern char virtual_banner[];
  491.     if (virtual_mode && !virtual_ftpaccess) {
  492. infile = fopen(virtual_banner, "r");
  493. if (infile) {
  494.     while (fgets(linebuf, sizeof(linebuf), infile) != NULL) {
  495. if ((crptr = strchr(linebuf, 'n')) != NULL)
  496.     *crptr = '';
  497. msg_massage(linebuf, outbuf, sizeof(outbuf));
  498. lreply(msgcode, "%s", outbuf);
  499.     }
  500.     fclose(infile);
  501. #ifndef NO_SUCKING_NEWLINES
  502.     lreply(msgcode, "");
  503. #endif
  504. }
  505.     }
  506.     else {
  507. #endif
  508. /* banner <path> */
  509. while (getaclentry("banner", &entry)) {
  510.     infile = fopen(ARG0, "r");
  511.     if (infile) {
  512. while (fgets(linebuf, sizeof(linebuf), infile) != NULL) {
  513.     if ((crptr = strchr(linebuf, 'n')) != NULL)
  514. *crptr = '';
  515.     msg_massage(linebuf, outbuf, sizeof(outbuf));
  516.     lreply(msgcode, "%s", outbuf);
  517. }
  518. fclose(infile);
  519. #ifndef NO_SUCKING_NEWLINES
  520. lreply(msgcode, "");
  521. #endif
  522.     }
  523. }
  524. #ifdef VIRTUAL
  525.     }
  526. #endif
  527. }
  528. /*************************************************************************/
  529. /* FUNCTION  : show_message                                              */
  530. /* PURPOSE   : Display a message on the user's terminal if the current   */
  531. /*             conditions are right                                      */
  532. /* ARGUMENTS : reply code to use, LOG_IN|CMD                             */
  533. /*************************************************************************/
  535. void show_message(int msgcode, int mode)
  536. {
  537.     char *crptr, linebuf[1024], outbuf[1024], class[MAXPATHLEN], cwd[MAXPATHLEN];
  538.     int show, which;
  539.     struct aclmember *entry = NULL;
  540.     FILE *infile;
  542.     if (mode == C_WD && cwd_beenhere(1) != 0)
  543. return;
  545. #ifdef HAVE_GETCWD
  546.     (void) getcwd(cwd, MAXPATHLEN - 1);
  547. #else
  548.     (void) getwd(cwd);
  549. #endif
  550.     (void) acl_getclass(class);
  552.     /* message <path> [<when> [<class>]] */
  553.     while (getaclentry("message", &entry)) {
  554. if (!ARG0)
  555.     continue;
  556. show = 0;
  558. if (mode == LOG_IN && (!ARG1 || !strcasecmp(ARG1, "login")))
  559.     if (!ARG2)
  560. show++;
  561.     else {
  562. for (which = 2; (which < MAXARGS) && ARG[which]; which++)
  563.     if (strcasecmp(class, ARG[which]) == 0)
  564. show++;
  565.     }
  566. if (mode == C_WD && ARG1 && !strncasecmp(ARG1, "cwd=", 4) &&
  567.     (!strcmp((ARG1) + 4, cwd) || *(ARG1 + 4) == '*' ||
  568.      !wu_fnmatch((ARG1) + 4, cwd, FNM_PATHNAME)))
  569.     if (!ARG2)
  570. show++;
  571.     else {
  572. for (which = 2; (which < MAXARGS) && ARG[which]; which++)
  573.     if (strcasecmp(class, ARG[which]) == 0)
  574. show++;
  575.     }
  576. if (show && (int) strlen(ARG0) > 0) {
  577.     infile = fopen(ARG0, "r");
  578.     if (infile) {
  579. while (fgets(linebuf, sizeof(linebuf), infile) != NULL) {
  580.     if ((crptr = strchr(linebuf, 'n')) != NULL)
  581. *crptr = '';
  582.     msg_massage(linebuf, outbuf, sizeof(outbuf));
  583.     lreply(msgcode, "%s", outbuf);
  584. }
  585. fclose(infile);
  586. #ifndef NO_SUCKING_NEWLINES
  587. lreply(msgcode, "");
  588. #endif
  589.     }
  590. }
  591.     }
  592. }
  594. /*************************************************************************/
  595. /* FUNCTION  : show_readme                                               */
  596. /* PURPOSE   : Display a message about a README file to the user if the  */
  597. /*             current conditions are right                              */
  598. /* ARGUMENTS : pointer to ACL buffer, reply code, LOG_IN|C_WD            */
  599. /*************************************************************************/
  601. void show_readme(int code, int mode)
  602. {
  603.     char **filelist, **sfilelist, class[MAXPATHLEN], cwd[MAXPATHLEN];
  604.     int show, which, days;
  605.     time_t clock;
  607.     struct stat buf;
  608.     struct tm *tp;
  609.     struct aclmember *entry = NULL;
  611.     if (cwd_beenhere(2) != 0)
  612. return;
  614. #ifdef HAVE_GETCWD
  615.     (void) getcwd(cwd, MAXPATHLEN - 1);
  616. #else
  617.     (void) getwd(cwd);
  618. #endif
  619.     (void) acl_getclass(class);
  621.     /* readme  <path> {<when>} */
  622.     while (getaclentry("readme", &entry)) {
  623. if (!ARG0)
  624.     continue;
  625. show = 0;
  627. if (mode == LOG_IN && (!ARG1 || !strcasecmp(ARG1, "login")))
  628.     if (!ARG2)
  629. show++;
  630.     else {
  631. for (which = 2; (which < MAXARGS) && ARG[which]; which++)
  632.     if (strcasecmp(class, ARG[which]) == 0)
  633. show++;
  634.     }
  635. if (mode == C_WD && ARG1 && !strncasecmp(ARG1, "cwd=", 4)
  636.     && (!strcmp((ARG1) + 4, cwd) || *(ARG1 + 4) == '*' ||
  637. !wu_fnmatch((ARG1) + 4, cwd, FNM_PATHNAME)))
  638.     if (!ARG2)
  639. show++;
  640.     else {
  641. for (which = 2; (which < MAXARGS) && ARG[which]; which++)
  642.     if (strcasecmp(class, ARG[which]) == 0)
  643. show++;
  644.     }
  645. if (show) {
  646.     globerr = NULL;
  647.     filelist = ftpglob(ARG0);
  648.     sfilelist = filelist; /* save to free later */
  649.     if (!globerr) {
  650. while (filelist && *filelist) {
  651.     errno = 0;
  652.     if (!stat(*filelist, &buf) &&
  653. (buf.st_mode & S_IFMT) == S_IFREG) {
  654. lreply(code, "Please read the file %s", *filelist);
  655. (void) time(&clock);
  656. tp = localtime(&clock);
  657. days = 365 * tp->tm_year + tp->tm_yday;
  658. tp = localtime((time_t *) & buf.st_mtime);
  659. days -= 365 * tp->tm_year + tp->tm_yday;
  660. /*
  661.    if (days == 0) {
  662.    lreply(code, "  it was last modified on %.24s - Today",
  663.    ctime((time_t *)&buf.st_mtime));
  664.    } else {
  665.  */
  666. lreply(code,
  667.    "  it was last modified on %.24s - %d day%s ago",
  668.        ctime((time_t *) & buf.st_mtime), days, days == 1 ? "" : "s");
  669. /*
  670.    }
  671.  */
  672.     }
  673.     filelist++;
  674. }
  675.     }
  676.     if (sfilelist) {
  677. blkfree(sfilelist);
  678. free((char *) sfilelist);
  679.     }
  680. }
  681.     }
  682. }
  684. /*************************************************************************/
  685. /* FUNCTION  : deny_badxfertype                                          */
  686. /* PURPOSE   : If user is in ASCII transfer mode and tries to retrieve a */
  687. /*             binary file, abort transfer and display appropriate error */
  688. /* ARGUMENTS : message code to use for denial, path of file to check for */
  689. /*             binary contents or NULL to assume binary file             */
  690. /*************************************************************************/
  692. int deny_badasciixfer(int msgcode, char *filepath)
  693. {
  695.     if (type == TYPE_A && !*filepath) {
  696. reply(msgcode, "This is a BINARY file, using ASCII mode to transfer will corrupt it.");
  697. return (1);
  698.     }
  699.     /* The hooks are here to prevent transfers of actual binary files, not
  700.      * just TAR or COMPRESS mode files... */
  701.     return (0);
  702. }
  704. /*************************************************************************/
  705. /* FUNCTION  : is_shutdown                                               */
  706. /* PURPOSE   :                                                           */
  707. /* ARGUMENTS :                                                           */
  708. /*************************************************************************/
  710. int is_shutdown(int quiet, int new)
  711. {
  712.     static struct tm tmbuf;
  713.     static struct stat s_last;
  714.     static time_t last = 0, shut, deny, disc;
  715.     static int valid;
  716.     static char text[2048];
  717.     struct stat s_cur;
  719.     extern char *autospout, Shutdown[];
  721.     FILE *fp;
  723.     int deny_off, disc_off;
  725.     time_t curtime = time(NULL);
  727.     char buf[1024], linebuf[1024];
  729.     if (Shutdown[0] == '' || stat(Shutdown, &s_cur))
  730. return (0);
  732.     if (s_last.st_mtime != s_cur.st_mtime) {
  733. s_last = s_cur;
  734. valid = 0;
  736. fp = fopen(Shutdown, "r");
  737. if (fp == NULL)
  738.     return (0);
  739. fgets(buf, sizeof(buf), fp);
  740. if (sscanf(buf, "%d %d %d %d %d %ld %ld", &tmbuf.tm_year, &tmbuf.tm_mon,
  741. &tmbuf.tm_mday, &tmbuf.tm_hour, &tmbuf.tm_min, &deny, &disc) != 7) {
  742.     (void) fclose(fp);
  743.     return (0);
  744. }
  745. valid = 1;
  746. deny_off = 3600 * (deny / 100) + 60 * (deny % 100);
  747. disc_off = 3600 * (disc / 100) + 60 * (disc % 100);
  749. tmbuf.tm_year -= 1900;
  750. tmbuf.tm_isdst = -1;
  751. shut = mktime(&tmbuf);
  752. strcpy(shuttime, ctime(&shut));
  754. disc = shut - disc_off;
  755. strcpy(disctime, ctime(&disc));
  757. deny = shut - deny_off;
  758. strcpy(denytime, ctime(&deny));
  760. text[0] = '';
  762. while (fgets(buf, sizeof(buf), fp) != NULL) {
  763.     msg_massage(buf, linebuf, sizeof(linebuf));
  764.     if ((strlen(text) + strlen(linebuf)) < sizeof(text))
  765. strcat(text, linebuf);
  766. }
  768. (void) fclose(fp);
  769.     }
  770.     if (!valid)
  771. return (0);
  773.     /* if last == 0, then is_shutdown() only called with quiet == 1 so far */
  774.     if (last == 0 && !quiet) {
  775. autospout = text; /* warn them for the first time */
  776. autospout_free = 0;
  777. last = curtime;
  778.     }
  779.     /* if a new connection and past deny time, tell caller to drop 'em */
  780.     if (new && curtime > deny)
  781. return (1);
  783.     /* if past disconnect time, tell caller to drop 'em */
  784.     if (curtime > disc)
  785. return (1);
  787.     /* if less than 60 seconds to disconnection, warn 'em continuously */
  788.     if (curtime > (disc - 60) && !quiet) {
  789. autospout = text;
  790. autospout_free = 0;
  791. last = curtime;
  792.     }
  793.     /* if less than 15 minutes to disconnection, warn 'em every 5 mins */
  794.     if (curtime > (disc - 60 * 15)) {
  795. if ((curtime - last) > (60 * 5) && !quiet) {
  796.     autospout = text;
  797.     autospout_free = 0;
  798.     last = curtime;
  799. }
  800.     }
  801.     /* if less than 24 hours to disconnection, warn 'em every 30 mins */
  802.     if (curtime < (disc - 24 * 60 * 60) && !quiet) {
  803. if ((curtime - last) > (60 * 30)) {
  804.     autospout = text;
  805.     autospout_free = 0;
  806.     last = curtime;
  807. }
  808.     }
  809.     /* if more than 24 hours to disconnection, warn 'em every 60 mins */
  810.     if (curtime > (disc - 24 * 60 * 60) && !quiet) {
  811. if ((curtime - last) >= (24 * 60 * 60)) {
  812.     autospout = text;
  813.     autospout_free = 0;
  814.     last = curtime;
  815. }
  816.     }
  817.     return (0);
  818. }
  820. void newer(char *date, char *path, int showlots)
  821. {
  822.     extern int ftw(const char *path, int (*fn) (char *, struct stat *, int), int depth);
  823.     struct tm tm;
  825.     if (sscanf(date, "%04d%02d%02d%02d%02d%02d",
  826.        &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
  827.        &tm.tm_hour, &tm.tm_min, &tm.tm_sec) == 6) {
  829. tm.tm_year -= 1900;
  830. tm.tm_mon--;
  831. tm.tm_isdst = -1;
  832. newer_time = mktime(&tm);
  833. dout = dataconn("file list", (off_t) - 1, "w");
  835. if (dout != NULL) {
  836.     /* As ftw allocates storage it needs a chance to cleanup, setting
  837.      * ftwflag prevents myoob from calling longjmp, incrementing
  838.      * ftwflag instead which causes check_newer to return non-zero
  839.      * which makes ftw return. */
  840.     ftwflag = 1;
  841.     transflag++;
  842.     show_fullinfo = showlots;
  843. #if defined(HAVE_FTW)
  844.     ftw(path, check_newer, -1);
  845. #else
  846.     treewalk(path, check_newer, -1, NULL);
  847. #endif
  849.     /* don't send a reply if myoob has already replied */
  850.     if (ftwflag == 1) {
  851. if (ferror(dout) != 0)
  852.     perror_reply(550, "Data connection");
  853. else
  854.     reply(226, "Transfer complete.");
  855.     }
  857.     (void) fclose(dout);
  858.     data = -1;
  859.     pdata = -1;
  860.     transflag = 0;
  861.     ftwflag = 0;
  862. }
  863.     }
  864.     else
  865. reply(501, "Bad DATE format");
  866. }
  868. int type_match(char *typelist)
  869. {
  870.     if (anonymous && strcasestr(typelist, "anonymous"))
  871. return (1);
  872.     if (guest && strcasestr(typelist, "guest"))
  873. return (1);
  874.     if (!guest && !anonymous && strcasestr(typelist, "real"))
  875. return (1);
  877.     if (strncasecmp(typelist, "class=", 6) == 0) {
  878. char class[1024];
  880. (void) acl_getclass(class);
  881. if (strcasecmp(typelist + 6, class) == 0)
  882.     return (1);
  883.     }
  885.     return (0);
  886. }
  888. int path_compare(char *p1, char *p2)
  889. {
  890.     if ((strcmp(p1, "*") == 0) || (wu_fnmatch(p1, p2, FNM_PATHNAME) == 0)) /* 0 means they matched */
  891. return (strlen(p1));
  892.     else
  893. return (-2);
  894. }
  896. void expand_id(void)
  897. {
  898.     char class[1024];
  899.     struct aclmember *entry = NULL;
  900.     (void) acl_getclass(class);
  901.     while (getaclentry("upload", &entry)) {
  902. char *q;
  903. int i = 0;
  904. int options = 1;
  905. int classfound = 0;
  906. int classmatched = 0;
  907. while (options
  908.        && (i < MAXARGS)
  909.        && ((q = entry->arg[i]) != (char *) NULL)
  910.        && (q[0] != '')) {
  911.     if (strcasecmp(q, "absolute") == 0)
  912. i++;
  913.     else if (strcasecmp(q, "relative") == 0)
  914. i++;
  915.     else if (strncasecmp(q, "class=", 6) == 0) {
  916. i++;
  917. classfound = 1;
  918. if (strcasecmp(q + 6, class) == 0)
  919.     classmatched = 1;
  920.     }
  921.     else if (strcmp(q, "-") == 0) {
  922. i++;
  923. options = 0;
  924.     }
  925.     else
  926. options = 0;
  927. }
  928. if (!classfound || classmatched) {
  929.     char buf[BUFSIZ];
  930.     /*
  931.        *  UID
  932.      */
  933.     if (((i + 3) < MAXARGS)
  934. && ((q = entry->arg[i + 3]) != (char *) NULL)
  935. && (q[0] != '')
  936. && (strcmp(q, "*") != 0)) {
  937. if (q[0] == '%')
  938.     sprintf(buf, "%s", q + 1);
  939. else {
  940.     struct passwd *pwent = getpwnam(q);
  941.     if (pwent)
  942. sprintf(buf, "%" PW_UID_FORMAT, pwent->pw_uid);
  943.     else
  944. sprintf(buf, "%d", 0);
  945. }
  946. entry->arg[i + 3] = (char *) malloc(strlen(buf) + 1);
  947. if (entry->arg[i + 3] == NULL) {
  948.     syslog(LOG_ERR, "calloc error in expand_id");
  949.     exit(0);
  950. }
  951. strcpy(entry->arg[i + 3], buf);
  952.     }
  953.     /*
  954.        *  GID
  955.      */
  956.     if (((i + 4) < MAXARGS)
  957. && ((q = entry->arg[i + 4]) != (char *) NULL)
  958. && (q[0] != '')
  959. && (strcmp(q, "*") != 0)) {
  960. if (q[0] == '%')
  961.     sprintf(buf, "%s", q + 1);
  962. else {
  963.     struct group *grent = getgrnam(q);
  964.     if (grent)
  965. sprintf(buf, "%" GR_GID_FORMAT, grent->gr_gid);
  966.     else
  967. sprintf(buf, "%d", 0);
  968.     endgrent();
  969. }
  970. entry->arg[i + 4] = (char *) malloc(strlen(buf) + 1);
  971. if (entry->arg[i + 4] == NULL) {
  972.     syslog(LOG_ERR, "calloc error in expand_id");
  973.     exit(0);
  974. }
  975. strcpy(entry->arg[i + 4], buf);
  976.     }
  977. }
  978.     }
  979. }
  981. int fn_check(char *name)
  982. {
  983.     /* check to see if this is a valid file name... path-filter <type>
  984.      * <message_file> <allowed_charset> <disallowed> */
  986.     struct aclmember *entry = NULL;
  987.     int j;
  988.     char *path;
  989. #if ! defined(HAVE_REGEXEC)
  990.     char *sp;
  991. #endif
  993. #ifdef M_UNIX
  994. #ifdef HAVE_REGEX
  995.     char *regp;
  996. #endif
  997. #endif
  999. #ifdef HAVE_REGEXEC
  1000.     regex_t regexbuf;
  1001.     regmatch_t regmatchbuf;
  1002. #endif
  1004. #ifdef LINUX
  1005.     re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
  1006. #endif
  1008.     while (getaclentry("path-filter", &entry) && ARG0 != NULL) {
  1009. if (type_match(ARG0) && ARG1 && ARG2) {
  1011.     /*
  1012.      * check *only* the basename
  1013.      */
  1015.     if ((path = strrchr(name, '/')))
  1016. ++path;
  1017.     else
  1018. path = name;
  1020.     /* is it in the allowed character set? */
  1021. #if defined(HAVE_REGEXEC)
  1022.     if (regcomp(&regexbuf, ARG2, REG_EXTENDED) != 0) {
  1023. reply(550, "HAVE_REGEX error");
  1024. #elif defined(HAVE_REGEX)
  1025. if ((sp = regcmp(ARG2, (char *) 0)) == NULL) {
  1026.     reply(550, "HAVE_REGEX error");
  1027. #else
  1028.     if ((sp = re_comp(ARG2)) != 0) {
  1029. perror_reply(550, sp);
  1030. #endif
  1031. return (0);
  1032.     }
  1033. #if defined(HAVE_REGEXEC)
  1034.     if (regexec(&regexbuf, path, 1, &regmatchbuf, 0) != 0) {
  1035. #elif defined(HAVE_REGEX)
  1036. #ifdef M_UNIX
  1037. regp = regex(sp, path);
  1038. free(sp);
  1039. if (regp == NULL) {
  1040. #else
  1041. if ((regex(sp, path)) == NULL) {
  1042. #endif
  1043. #else
  1044.     if ((re_exec(path)) != 1) {
  1045. #endif
  1046. pr_mesg(550, ARG1);
  1047. reply(550, "%s: Permission denied on server. (Filename (accept))", name);
  1048. return (0);
  1049.     }
  1050.     /* is it in any of the disallowed regexps */
  1052.     for (j = 3; j < MAXARGS; ++j) {
  1053. /* ARGj == entry->arg[j] */
  1054. if (entry->arg[j]) {
  1055. #if defined(HAVE_REGEXEC)
  1056.     if (regcomp(&regexbuf, entry->arg[j], REG_EXTENDED) != 0) {
  1057. reply(550, "HAVE_REGEX error");
  1058. #elif defined(HAVE_REGEX)
  1059. if ((sp = regcmp(entry->arg[j], (char *) 0)) == NULL) {
  1060.     reply(550, "HAVE_REGEX error");
  1061. #else
  1062.     if ((sp = re_comp(entry->arg[j])) != 0) {
  1063. perror_reply(550, sp);
  1064. #endif
  1065. return (0);
  1066.     }
  1067. #if defined(HAVE_REGEXEC)
  1068.     if (regexec(&regexbuf, path, 1, &regmatchbuf, 0) == 0) {
  1069. #elif defined(HAVE_REGEX)
  1070. #ifdef M_UNIX
  1071. regp = regex(sp, path);
  1072. free(sp);
  1073. if (regp != NULL) {
  1074. #else
  1075. if ((regex(sp, path)) != NULL) {
  1076. #endif
  1077. #else
  1078.     if ((re_exec(path)) == 1) {
  1079. #endif
  1080. pr_mesg(550, ARG1);
  1081. reply(550, "%s: Permission denied on server. (Filename (deny))", name);
  1082. return (0);
  1083.     }
  1084. }
  1085.     }
  1086. }
  1087.     }
  1088.     return (1);
  1089. }
  1091. int dir_check(char *name, uid_t * uid, gid_t * gid, int *d_mode, int *valid)
  1092. {
  1093.     struct aclmember *entry = NULL;
  1094.     int match_value = -1;
  1095.     char *ap2 = NULL;
  1096.     char *ap3 = NULL;
  1097.     char *ap4 = NULL;
  1098.     char *ap5 = NULL;
  1099.     char *ap6 = NULL;
  1100.     char *ap7 = NULL;
  1101.     char cwdir[MAXPATHLEN];
  1102.     char *pwdir;
  1103.     char abspwdir[MAXPATHLEN];
  1104.     char relpwdir[MAXPATHLEN];
  1105.     char path[MAXPATHLEN];
  1106.     char *sp;
  1107.     struct stat stbuf;
  1108.     int stat_result = -1;
  1109.     char class[1024];
  1110.     extern char *home;
  1111.     extern char chroot_path[];
  1113.     (void) acl_getclass(class);
  1115.     *valid = 0;
  1116.     /* what's our current directory? */
  1118.     /* XXX We could use dynamic RAM to store this path, but I'd rather just bail
  1119.        out with an error. The rest of wu is so crufy that a long path might
  1120.        just blow up later */
  1122.     if ((strlen(name) + 1) > sizeof(path)) {
  1123. perror_reply(550, "Path too long");
  1124. return (-1);
  1125.     }
  1127.     strcpy(path, name);
  1128.     sp = strrchr(path, '/');
  1129.     if (sp)
  1130. *sp = '';
  1131.     else
  1132. strcpy(path, ".");
  1134.     if ((fb_realpath(path, cwdir)) == NULL) {
  1135. perror_reply(550, "Could not determine cwdir");
  1136. return (-1);
  1137.     }
  1139.     if ((fb_realpath(home, relpwdir)) == NULL) {
  1140. perror_reply(550, "Could not determine pwdir");
  1141. return (-1);
  1142.     }
  1144.     if ((wu_realpath(home, abspwdir, chroot_path)) == NULL) {
  1145. perror_reply(550, "Could not determine pwdir");
  1146. return (-1);
  1147.     }
  1149.     while (getaclentry("upload", &entry)) {
  1150. char *q;
  1151. int i = 0;
  1152. int options = 1;
  1153. int classfound = 0;
  1154. int classmatched = 0;
  1155. pwdir = abspwdir;
  1156. while (options
  1157.        && (i < MAXARGS)
  1158.        && ((q = entry->arg[i]) != (char *) NULL)
  1159.        && (q[0] != '')) {
  1160.     if (strcasecmp(q, "absolute") == 0) {
  1161. i++;
  1162. pwdir = abspwdir;
  1163.     }
  1164.     else if (strcasecmp(q, "relative") == 0) {
  1165. i++;
  1166. pwdir = relpwdir;
  1167.     }
  1168.     else if (strncasecmp(q, "class=", 6) == 0) {
  1169. i++;
  1170. classfound = 1;
  1171. if (strcasecmp(q + 6, class) == 0)
  1172.     classmatched = 1;
  1173.     }
  1174.     else if (strcmp(q, "-") == 0) {
  1175. i++;
  1176. options = 0;
  1177.     }
  1178.     else
  1179. options = 0;
  1180. }
  1181. if (!classfound || classmatched) {
  1182.     int j;
  1183.     if (((i + 1) < MAXARGS)
  1184. && ((q = entry->arg[i]) != (char *) NULL)
  1185. && (q[0] != '')
  1186. && (0 < path_compare(q, pwdir))
  1187. && ((j = path_compare(entry->arg[i + 1], cwdir)) >= match_value)) {
  1188. match_value = j;
  1190. ap2 = NULL;
  1191. if (((i + 2) < MAXARGS)
  1192.     && ((q = entry->arg[i + 2]) != (char *) NULL)
  1193.     && (q[0] != ''))
  1194.     ap2 = q;
  1196. ap3 = NULL;
  1197. if (((i + 3) < MAXARGS)
  1198.     && ((q = entry->arg[i + 3]) != (char *) NULL)
  1199.     && (q[0] != ''))
  1200.     ap3 = q;
  1202. ap4 = NULL;
  1203. if (((i + 4) < MAXARGS)
  1204.     && ((q = entry->arg[i + 4]) != (char *) NULL)
  1205.     && (q[0] != ''))
  1206.     ap4 = q;
  1208. ap5 = NULL;
  1209. if (((i + 5) < MAXARGS)
  1210.     && ((q = entry->arg[i + 5]) != (char *) NULL)
  1211.     && (q[0] != ''))
  1212.     ap5 = q;
  1214. ap6 = NULL;
  1215. if (((i + 6) < MAXARGS)
  1216.     && ((q = entry->arg[i + 6]) != (char *) NULL)
  1217.     && (q[0] != ''))
  1218.     ap6 = q;
  1220. ap7 = NULL;
  1221. if (((i + 7) < MAXARGS)
  1222.     && ((q = entry->arg[i + 7]) != (char *) NULL)
  1223.     && (q[0] != ''))
  1224.     ap7 = q;
  1225.     }
  1226. }
  1227.     }
  1229.     if (anonymous && (match_value < 0)) {
  1230. reply(550, "%s: Permission denied on server. (Upload dirs)", name);
  1231. return (0);
  1232.     }
  1233.     if ((ap2 && !strcasecmp(ap2, "no"))
  1234. || (ap3 && !strcasecmp(ap3, "nodirs"))
  1235. || (ap6 && !strcasecmp(ap6, "nodirs"))) {
  1236. reply(550, "%s: Permission denied on server. (Upload dirs)", name);
  1237. return (0);
  1238.     }
  1239.     if ((ap3 && *ap3 == '*') || (ap4 && *ap4 == '*'))
  1240. stat_result = stat(path, &stbuf);
  1241.     if (ap3) {
  1242. if ((ap3[0] != '*') || (ap3[1] != ''))
  1243.     *uid = atoi(ap3); /* the uid  */
  1244. else if (stat_result == 0)
  1245.     *uid = stbuf.st_uid;
  1246.     }
  1247.     if (ap4) {
  1248. if ((ap4[0] != '*') || (ap4[1] != ''))
  1249.     *gid = atoi(ap4); /* the gid */
  1250. else if (stat_result == 0)
  1251.     *gid = stbuf.st_gid;
  1252.     }
  1253.     if (ap7) {
  1254. sscanf(ap7, "%o", d_mode);
  1255. *valid = 1;
  1256.     }
  1257.     else if (ap5) {
  1258. sscanf(ap5, "%o", d_mode);
  1259. if (*d_mode & 0600)
  1260.     *d_mode |= 0100;
  1261. if (*d_mode & 0060)
  1262.     *d_mode |= 0010;
  1263. if (*d_mode & 0006)
  1264.     *d_mode |= 0001;
  1265. *valid = 1;
  1266.     }
  1267.     return (1);
  1268. }
  1270. int upl_check(char *name, uid_t * uid, gid_t * gid, int *f_mode, int *valid)
  1271. {
  1272.     int match_value = -1;
  1273.     char cwdir[MAXPATHLEN];
  1274.     char *pwdir;
  1275.     char abspwdir[MAXPATHLEN];
  1276.     char relpwdir[MAXPATHLEN];
  1277.     char path[MAXPATHLEN];
  1278.     char *sp;
  1279.     struct stat stbuf;
  1280.     int stat_result = -1;
  1281.     char *ap2 = NULL;
  1282.     char *ap3 = NULL;
  1283.     char *ap4 = NULL;
  1284.     char *ap5 = NULL;
  1285.     struct aclmember *entry = NULL;
  1286.     char class[1024];
  1287.     extern char *home;
  1288.     extern char chroot_path[];
  1290.     *valid = 0;
  1291.     (void) acl_getclass(class);
  1293.     /* what's our current directory? */
  1295.     /* XXX We could use dynamic RAM to store this path, but I'd rather just bail
  1296.        out with an error. The rest of wu is so crufy that a long path might
  1297.        just blow up later */
  1299.     if ((strlen(name) + 1) > sizeof(path)) {
  1300. perror_reply(553, "Path too long");
  1301. return (-1);
  1302.     }
  1304.     strcpy(path, name);
  1305.     sp = strrchr(path, '/');
  1306.     if (sp)
  1307. *sp = '';
  1308.     else
  1309. strcpy(path, ".");
  1311.     if ((fb_realpath(path, cwdir)) == NULL) {
  1312. perror_reply(553, "Could not determine cwdir");
  1313. return (-1);
  1314.     }
  1316.     if ((wu_realpath(home, abspwdir, chroot_path)) == NULL) {
  1317. perror_reply(553, "Could not determine pwdir");
  1318. return (-1);
  1319.     }
  1321.     if ((fb_realpath(home, relpwdir)) == NULL) {
  1322. perror_reply(553, "Could not determine pwdir");
  1323. return (-1);
  1324.     }
  1326.     /*
  1327.        *  we are doing a "best match"... ..so we keep track of what "match
  1328.        *  value" we have received so far...
  1329.      */
  1330.     while (getaclentry("upload", &entry)) {
  1331. char *q;
  1332. int i = 0;
  1333. int options = 1;
  1334. int classfound = 0;
  1335. int classmatched = 0;
  1336. pwdir = abspwdir;
  1337. while (options
  1338.        && (i < MAXARGS)
  1339.        && ((q = entry->arg[i]) != (char *) NULL)
  1340.        && (q[0] != '')) {
  1341.     if (strcasecmp(q, "absolute") == 0) {
  1342. i++;
  1343. pwdir = abspwdir;
  1344.     }
  1345.     else if (strcasecmp(q, "relative") == 0) {
  1346. i++;
  1347. pwdir = relpwdir;
  1348.     }
  1349.     else if (strncasecmp(q, "class=", 6) == 0) {
  1350. i++;
  1351. classfound = 1;
  1352. if (strcasecmp(q + 6, class) == 0)
  1353.     classmatched = 1;
  1354.     }
  1355.     else if (strcmp(q, "-") == 0) {
  1356. i++;
  1357. options = 0;
  1358.     }
  1359.     else
  1360. options = 0;
  1361. }
  1362. if (!classfound || classmatched) {
  1363.     int j;
  1364.     if (((i + 1) < MAXARGS)
  1365. && ((q = entry->arg[i]) != (char *) NULL)
  1366. && (q[0] != '')
  1367. && (0 < path_compare(q, pwdir))
  1368. && ((j = path_compare(entry->arg[i + 1], cwdir)) >= match_value)) {
  1369. match_value = j;
  1371. ap2 = NULL;
  1372. if (((i + 2) < MAXARGS)
  1373.     && ((q = entry->arg[i + 2]) != (char *) NULL)
  1374.     && (q[0] != ''))
  1375.     ap2 = q;
  1377. ap3 = NULL;
  1378. if (((i + 3) < MAXARGS)
  1379.     && ((q = entry->arg[i + 3]) != (char *) NULL)
  1380.     && (q[0] != ''))
  1381.     ap3 = q;
  1383. ap4 = NULL;
  1384. if (((i + 4) < MAXARGS)
  1385.     && ((q = entry->arg[i + 4]) != (char *) NULL)
  1386.     && (q[0] != ''))
  1387.     ap4 = q;
  1389. ap5 = NULL;
  1390. if (((i + 5) < MAXARGS)
  1391.     && ((q = entry->arg[i + 5]) != (char *) NULL)
  1392.     && (q[0] != ''))
  1393.     ap5 = q;
  1394.     }
  1395. }
  1396.     }
  1398.     if (ap3
  1399. && ((!strcasecmp("dirs", ap3))
  1400.     || (!strcasecmp("nodirs", ap3))))
  1401. ap3 = NULL;
  1403.     /*
  1404.        *  if we did get matches ... else don't do any of this stuff
  1405.      */
  1406.     if (match_value >= 0) {
  1407. if (!strcasecmp(ap2, "yes")) {
  1408.     if ((ap3 && *ap3 == '*') || (ap4 && *ap4 == '*'))
  1409. stat_result = stat(path, &stbuf);
  1410.     if (ap3) {
  1411. if ((ap3[0] != '*') || (ap3[1] != ''))
  1412.     *uid = atoi(ap3); /* the uid  */
  1413. else if (stat_result == 0)
  1414.     *uid = stbuf.st_uid;
  1415.     }
  1416.     if (ap4) {
  1417. if ((ap4[0] != '*') || (ap4[1] != ''))
  1418.     *gid = atoi(ap4); /* the gid  */
  1419. else if (stat_result == 0)
  1420.     *gid = stbuf.st_gid;
  1421. *valid = 1;
  1422.     }
  1423.     if (ap5)
  1424. sscanf(ap5, "%o", f_mode); /* the mode */
  1425. }
  1426. else {
  1427.     reply(553, "%s: Permission denied on server. (Upload)", name);
  1428.     return (-1);
  1429. }
  1430.     }
  1431.     else {
  1432. /*
  1433.    *  upload defaults to "permitted"
  1434.  */
  1435. /* Not if anonymous */
  1436. if (anonymous) {
  1437.     reply(553, "%s: Permission denied on server. (Upload)", name);
  1438.     return (-1);
  1439. }
  1440. return (1);
  1441.     }
  1443.     return (match_value);
  1444. }
  1446. int del_check(char *name)
  1447. {
  1448.     int pdelete = (anonymous ? 0 : 1);
  1449.     struct aclmember *entry = NULL;
  1451.     while (getaclentry("delete", &entry) && ARG0 && ARG1 != NULL) {
  1452. if (type_match(ARG1))
  1453.     if (anonymous) {
  1454. if (*ARG0 == 'y')
  1455.     pdelete = 1;
  1456.     }
  1457.     else if (*ARG0 == 'n')
  1458. pdelete = 0;
  1459.     }
  1461. /* H* fix: no deletion, period. You put a file here, I get to look at it. */
  1462. #ifdef PARANOID
  1463.     pdelete = 0;
  1464. #endif
  1466.     if (!pdelete) {
  1467. reply(553, "%s: Permission denied on server. (Delete)", name);
  1468. return (0);
  1469.     }
  1470.     else {
  1471. return (1);
  1472.     }
  1473. }
  1475. /* The following is from the Debian add-ons. */
  1477. #define lbasename(x) (strrchr(x,'/')?1+strrchr(x,'/'):x)
  1479. int regexmatch(char *name, char *rgexp)
  1480. {
  1482. #ifdef M_UNIX
  1483. #ifdef HAVE_REGEX
  1484.     char *regp;
  1485. #endif
  1486. #endif
  1488. #ifdef HAVE_REGEXEC
  1489.     regex_t regexbuf;
  1490.     regmatch_t regmatchbuf;
  1491. #else
  1492.     char *sp;
  1493. #endif
  1495. #if defined(HAVE_REGEXEC)
  1496.     if (regcomp(&regexbuf, rgexp, REG_EXTENDED) != 0) {
  1497. reply(553, "HAVE_REGEX error");
  1498. #elif defined(HAVE_REGEX)
  1499. if ((sp = regcmp(rgexp, (char *) 0)) == NULL) {
  1500.     reply(553, "HAVE_REGEX error");
  1501. #else
  1502.     if ((sp = re_comp(rgexp)) != 0) {
  1503. perror_reply(553, sp);
  1504. #endif
  1505. return (0);
  1506.     }
  1508. #if defined(HAVE_REGEXEC)
  1509.     if (regexec(&regexbuf, name, 1, &regmatchbuf, 0) != 0) {
  1510. #elif defined(HAVE_REGEX)
  1511. #ifdef M_UNIX
  1512. regp = regex(sp, name);
  1513. free(sp);
  1514. if (regp == NULL) {
  1515. #else
  1516. if ((regex(sp, name)) == NULL) {
  1517. #endif
  1518. #else
  1519.     if ((re_exec(name)) != 1) {
  1520. #endif
  1521. return (0);
  1522.     }
  1523.     return (1);
  1524. }
  1526. static int allow_retrieve(char *name)
  1527. {
  1528.     char realname[MAXPATHLEN + 1];
  1529.     char localname[MAXPATHLEN + 1];
  1530.     char *whichname;
  1531.     int i;
  1532.     size_t len;
  1533.     struct aclmember *entry = NULL;
  1534.     char *p, *q;
  1535.     int options;
  1536.     int classfound;
  1537.     int classmatched;
  1538.     char class[1024];
  1540.     extern char chroot_path[];
  1542.     (void) acl_getclass(class);
  1543.     if ((name == (char *) NULL)
  1544. || (*name == ''))
  1545. return 0;
  1546.     fb_realpath(name, localname);
  1547.     wu_realpath(name, realname, chroot_path);
  1548.     while (getaclentry("allow-retrieve", &entry)) {
  1549. whichname = realname;
  1550. i = 0;
  1551. options = 1;
  1552. classfound = 0;
  1553. classmatched = 0;
  1554. while (options
  1555.        && (i < MAXARGS)
  1556.        && ((q = entry->arg[i]) != (char *) NULL)
  1557.        && (q[0] != '')) {
  1558.     if (strcasecmp(q, "absolute") == 0) {
  1559. i++;
  1560. whichname = realname;
  1561.     }
  1562.     else if (strcasecmp(q, "relative") == 0) {
  1563. i++;
  1564. whichname = localname;
  1565.     }
  1566.     else if (strncasecmp(q, "class=", 6) == 0) {
  1567. i++;
  1568. classfound = 1;
  1569. if (strcasecmp(q + 6, class) == 0)
  1570.     classmatched = 1;
  1571.     }
  1572.     else if (strcmp(q, "-") == 0) {
  1573. i++;
  1574. options = 0;
  1575.     }
  1576.     else
  1577. options = 0;
  1578. }
  1579. if (!classfound || classmatched) {
  1580.     for (; (i < MAXARGS) && ((q = entry->arg[i]) != (char *) NULL) && (q[0] != ''); i++) {
  1581. len = strlen(q);
  1582. p = (q[0] == '/') ? whichname : lbasename(whichname);
  1583. if (!wu_fnmatch(q, p, FNM_PATHNAME | FNM_LEADING_DIR)) {
  1584.     return 1;
  1585. }
  1586.     }
  1587. }
  1588.     }
  1589.     return 0;
  1590. }
  1592. int checknoretrieve(char *name)
  1593. {
  1594.     char realname[MAXPATHLEN + 1];
  1595.     char localname[MAXPATHLEN + 1];
  1596.     char *whichname;
  1597.     int i;
  1598.     size_t len;
  1599.     struct aclmember *entry = NULL;
  1600.     char *p, *q;
  1601.     int options;
  1602.     int classfound;
  1603.     int classmatched;
  1604.     char class[1024];
  1606.     extern struct passwd *pw;
  1607.     extern char chroot_path[];
  1608.     extern char *remoteident;
  1610.     (void) acl_getclass(class);
  1611.     if ((name == (char *) NULL)
  1612. || (*name == ''))
  1613. return 0;
  1614.     fb_realpath(name, localname);
  1615.     wu_realpath(name, realname, chroot_path);
  1616.     while (getaclentry("noretrieve", &entry)) {
  1617. whichname = realname;
  1618. i = 0;
  1619. options = 1;
  1620. classfound = 0;
  1621. classmatched = 0;
  1622. while (options
  1623.        && (i < MAXARGS)
  1624.        && ((q = entry->arg[i]) != (char *) NULL)
  1625.        && (q[0] != '')) {
  1626.     if (strcasecmp(q, "absolute") == 0) {
  1627. i++;
  1628. whichname = realname;
  1629.     }
  1630.     else if (strcasecmp(q, "relative") == 0) {
  1631. i++;
  1632. whichname = localname;
  1633.     }
  1634.     else if (strncasecmp(q, "class=", 6) == 0) {
  1635. i++;
  1636. classfound = 1;
  1637. if (strcasecmp(q + 6, class) == 0)
  1638.     classmatched = 1;
  1639.     }
  1640.     else if (strcmp(q, "-") == 0) {
  1641. i++;
  1642. options = 0;
  1643.     }
  1644.     else
  1645. options = 0;
  1646. }
  1647. if (!classfound || classmatched) {
  1648.     for (; (i < MAXARGS) && ((q = entry->arg[i]) != (char *) NULL) && (q[0] != ''); i++) {
  1649. len = strlen(q);
  1650. p = (q[0] == '/') ? whichname : lbasename(whichname);
  1651. if (!wu_fnmatch(q, p, FNM_PATHNAME | FNM_LEADING_DIR)) {
  1652.     if (!allow_retrieve(name)) {
  1653. #ifdef VERBOSE_ERROR_LOGING
  1654. syslog(LOG_NOTICE, "%s of %s tried to download %s", pw->pw_name, remoteident, realname);
  1655. #endif
  1656. reply(550, "%s is marked unretrievable", localname);
  1657. return 1;
  1658.     }
  1659. }
  1660.     }
  1661. }
  1662.     }
  1663.     return 0;
  1664. }
  1666. #ifdef QUOTA
  1668. #ifndef MNTMAXSTR
  1669. #define MNTMAXSTR 2048 /* And hope it's enough */
  1670. #endif
  1672. #ifdef QUOTA_DEVICE
  1674. int path_to_device(char *pathname, char *result)
  1675. {
  1676.     FILE *fp;
  1677. #ifdef HAS_OLDSTYLE_GETMNTENT
  1678.     struct mnttab static_mp;
  1679.     struct mnttab *mp = &static_mp;
  1680. #else
  1681.     struct mntent *mp;
  1682. #endif
  1683.     struct mount_ent {
  1684. char mnt_fsname[MNTMAXSTR], mnt_dir[MNTMAXSTR];
  1685. struct mount_ent *next;
  1686.     } mountent;
  1687.     struct mount_ent *current, *start, *new;
  1688.     char path[1024], mnt_dir[1024], *pos;
  1689.     int flag = 1;
  1690.     extern char chroot_path[];
  1692.     start = current = NULL;
  1693. #ifdef HAS_OLDSTYLE_GETMNTENT
  1694.     fp = fopen(MNTTAB, "r");
  1695. #else
  1696.     fp = setmntent(MNTTAB, "r");
  1697. #endif
  1698.     if (fp == NULL)
  1699. return 0;
  1700. #ifdef HAS_OLDSTYLE_GETMNTENT
  1701.     while (getmntent(fp, &static_mp) == 0)
  1702. #else
  1703.     while (mp = getmntent(fp))
  1704. #endif
  1705.     {
  1706. if (!(new = (struct mount_ent *) malloc(sizeof(mountent)))) {
  1707.     perror("malloc");
  1708.     flag = 0;
  1709.     break;
  1710. }
  1712. if (!start)
  1713.     start = current = new;
  1714. else
  1715.     current = current->next = new;
  1717. #ifdef HAS_OLDSTYLE_GETMNTENT
  1718. strncpy(current->mnt_fsname, mp->mnt_special, strlen(mp->mnt_special) + 1);
  1719. strncpy(current->mnt_dir, mp->mnt_mountp, strlen(mp->mnt_mountp) + 1);
  1720. #else
  1721. strncpy(current->mnt_fsname, mp->mnt_fsname, strlen(mp->mnt_fsname) + 1);
  1722. strncpy(current->mnt_dir, mp->mnt_dir, strlen(mp->mnt_dir) + 1);
  1723. #endif
  1724.     }
  1725. #ifdef HAS_OLDSTYLE_GETMNTENT
  1726.     fclose(fp);
  1727. #else
  1728.     endmntent(fp);
  1729. #endif
  1730.     current->next = NULL;
  1732.     wu_realpath(pathname, path, chroot_path);
  1734.     while (*path && flag) {
  1735. current = start;
  1736. while (current && flag) {
  1737.     if (strcmp(current->mnt_dir, "swap")) {
  1738. wu_realpath(current->mnt_dir, mnt_dir, chroot_path);
  1739. if (!strcmp(mnt_dir, path)) {
  1740.     flag = 0;
  1741.     /* no support for remote quota yet */
  1742.     if (!strchr(current->mnt_fsname, ':'))
  1743. strcpy(result, current->mnt_fsname);
  1744. }
  1745.     }
  1746.     current = current->next;
  1747. }
  1748. if (!((pos = strrchr(path, '/')) - path) && strlen(path) > 1)
  1749.     strcpy(path, "/");
  1750. else
  1751.     path[pos - path] = '';
  1752.     }
  1753.     while (current) {
  1754. new = current->next;
  1755. free(current);
  1756. current = new;
  1757.     }
  1758.     return 1;
  1759. }
  1760. #endif
  1762. void get_quota(char *fs, int uid)
  1763. {
  1764.     char mnt_fsname[MNTMAXSTR];
  1765. #ifdef HAS_NO_QUOTACTL
  1766.     int dirfd;
  1767.     struct quotctl qp;
  1769.     if (path_to_device(fs, mnt_fsname)) {
  1770. dirfd = open(fs, O_RDONLY);
  1771. qp.op = Q_GETQUOTA;
  1772. qp.uid = uid;
  1773. qp.addr = (char *) &quota;
  1774. ioctl(dirfd, Q_QUOTACTL, &qp);
  1775. close(dirfd);
  1776.     }
  1777. #else
  1778. #ifdef QUOTA_DEVICE
  1780.     if (path_to_device(fs, mnt_fsname))
  1781. #ifdef QCMD
  1782. quotactl(QCMD(Q_GETQUOTA, USRQUOTA), mnt_fsname, uid, (char *) &quota);
  1783. #else
  1784. quotactl(Q_GETQUOTA, mnt_fsname, uid, (char *) &quota);
  1785. #endif
  1786. #else
  1787.     quotactl(fs, QCMD(Q_GETQUOTA, USRQUOTA), uid, (char *) &quota);
  1788. #endif
  1789. #endif /* HAS_NO_QUOTACTL */
  1790. }
  1792. char *time_quota(long curstate, long softlimit, long timelimit, char *timeleft)
  1793. {
  1794.     struct timeval tv;
  1796.     gettimeofday(&tv, NULL);
  1797.     if (softlimit && curstate >= softlimit) {
  1798. if (timelimit == 0) {
  1799.     strcpy(timeleft, "NOT STARTED");
  1800. }
  1801. else if (timelimit > tv.tv_sec) {
  1802.     fmttime(timeleft, timelimit - tv.tv_sec);
  1803. }
  1804. else {
  1805.     strcpy(timeleft, "EXPIRED");
  1806. }
  1807.     }
  1808.     else {
  1809. timeleft[0] = '';
  1810.     }
  1811.     return (timeleft);
  1812. }
  1814. void fmttime(char *buf, register long time)
  1815. {
  1816.     int i;
  1817.     static struct {
  1818. int c_secs; /* conversion units in secs */
  1819. char *c_str; /* unit string */
  1820.     } cunits[] = {
  1821. {
  1822.     60 *60 * 24 * 28, "months"
  1823. } ,
  1824. {
  1825.     60 *60 * 24 * 7, "weeks"
  1826. } ,
  1827. {
  1828.     60 *60 * 24, "days"
  1829. } ,
  1830. {
  1831.     60 *60, "hours"
  1832. } ,
  1833. {
  1834.     60, "mins"
  1835. } ,
  1836. {
  1837.     1, "secs"
  1838. }
  1839.     };
  1841.     if (time <= 0) {
  1842. strcpy(buf, "EXPIRED");
  1843. return;
  1844.     }
  1845.     for (i = 0; i < sizeof(cunits) / sizeof(cunits[0]); i++) {
  1846. if (time >= cunits[i].c_secs)
  1847.     break;
  1848.     }
  1849.     sprintf(buf, "%.1f %s", (double) time / cunits[i].c_secs, cunits[i].c_str);
  1850. }
  1852. #endif
  1854. #ifdef QUOTA
  1855. #if (defined(LINUX) && !defined(AUTOCONF)) || (defined(AUTOCONF) && !defined(HAVE_QUOTACTL) && defined(__linux__))
  1856. /* I have no idea why I can't find 'quotactl()' in my libs, here's the source - GAL */
  1857. /* This was a bug in truly ancient libc's (prior to 5.3.something). It isn't
  1858.    needed on any modern version of Linux. */
  1860. /*
  1861.  * QUOTA    An implementation of the diskquota system for the LINUX
  1862.  *          operating system. QUOTA is implemented using the BSD systemcall
  1863.  *          interface as the means of communication with the user level.
  1864.  *          Should work for all filesystems because of integration into the
  1865.  *          VFS layer of the operating system.
  1866.  *          This is based on the Melbourne quota system wich uses both user and
  1867.  *          group quota files.
  1868.  *
  1869.  *          System call interface.
  1870.  *
  1871.  * Version: $Id: extensions.c,v 1.46 1999/10/14 14:36:52 wuftpd Exp $
  1872.  *
  1873.  * Author:  Marco van Wieringen <mvw@planets.ow.nl> <mvw@tnix.net>
  1874.  *
  1875.  *          This program is free software; you can redistribute it and/or
  1876.  *          modify it under the terms of the GNU General Public License
  1877.  *          as published by the Free Software Foundation; either version
  1878.  *          2 of the License, or (at your option) any later version.
  1879.  */
  1880. #if defined(__alpha__)
  1881. #include <errno.h>
  1882. #include <sys/types.h>
  1883. #include <syscall.h>
  1884. #include <asm/unistd.h>
  1886. int quotactl(int cmd, const char *special, int id, caddr_t addr)
  1887. {
  1888.     return syscall(__NR_quotactl, cmd, special, id, addr);
  1889. }
  1890. #else /* __alpha__ */
  1891. #include <sys/types.h>
  1892. #define __LIBRARY__
  1893. #include <linux/unistd.h>
  1895. _syscall4(int, quotactl, int, cmd, const char *, special, int, id, caddr_t, addr);
  1896. #endif /* __alpha__ */
  1897. #elif !defined(HAVE_QUOTACTL) /* LINUX */
  1898. #ifdef QUOTA_DEVICE
  1899. /* I have no idea why I can't find 'quotactl()' in my libs, here's the source - keller */
  1901. int quotactl(int cmd, const char *special, int id, caddr_t addr)
  1902. {
  1903.     struct quotctl {
  1904. int op;
  1905. uid_t uid;
  1906. caddr_t addr;
  1907.     } qp;
  1908.     /*
  1909.      * open up the quota file in the root directory to get the file descriptor.
  1910.      * if no quota file exists, quotas are not enabled.
  1911.      */
  1912.     FILE *qf;
  1913.     char mnt_pnt[1024];
  1915.     mnt_pnt[0] = '';
  1916.     strncpy(mnt_pnt, special, strlen(mnt_pnt));
  1917.     strncat(mnt_pnt, "/quota", strlen(mnt_pnt));
  1919.     qf = fopen(mnt_pnt, "r");
  1920.     if (qf == NULL)
  1921. return(-1);
  1923.     qp.op = Q_GETQUOTA;
  1924.     qp.uid = id;
  1925.     qp.addr = addr;
  1927.     return ioctl((int) qf, (int) Q_QUOTACTL, qp);
  1928. }
  1930. #endif /* QUOTA_DEVICE */
  1931. #endif /* LINUX */
  1932. #endif /* QUOTA */
  1934. #ifdef THROUGHPUT
  1936. int file_compare(char *patterns, char *file)
  1937. {
  1938.     char buf[MAXPATHLEN];
  1939.     char *cp;
  1940.     char *cp2;
  1941.     int i;
  1942.     int matches = 0;
  1944.     strncpy(buf, patterns, sizeof(buf));
  1945.     buf[sizeof(buf) - 1] = '';
  1946.     i = strlen(buf);
  1947.     buf[i++] = ',';
  1948.     buf[i++] = '';
  1950.     cp = buf;
  1951.     while ((cp2 = strchr(cp, ',')) != NULL) {
  1952. *cp2++ = '';
  1953. if (wu_fnmatch(cp, file, FNM_PATHNAME) == 0) {
  1954.     matches = 1;
  1955.     break;
  1956. }
  1957.     }
  1958.     return matches;
  1959. }
  1961. int remote_compare(char *patterns)
  1962. {
  1963.     char buf[MAXPATHLEN];
  1964.     char *cp;
  1965.     char *cp2;
  1966.     int i;
  1967.     int matches = 0;
  1969.     strncpy(buf, patterns, sizeof(buf));
  1970.     buf[sizeof(buf) - 1] = '';
  1971.     i = strlen(buf);
  1972.     buf[i++] = ',';
  1973.     buf[i++] = '';
  1975.     cp = buf;
  1976.     while ((cp2 = strchr(cp, ',')) != NULL) {
  1977. *cp2++ = '';
  1978. if (hostmatch(cp, remoteaddr, remotehost)) {
  1979.     matches = 1;
  1980.     break;
  1981. }
  1982.     }
  1983.     return matches;
  1984. }
  1986. void throughput_calc(char *name, int *bps, double *bpsmult)
  1987. {
  1988.     int match_value = -1;
  1989.     char cwdir[MAXPATHLEN];
  1990.     char pwdir[MAXPATHLEN];
  1991.     char path[MAXPATHLEN];
  1992.     char file[MAXPATHLEN];
  1993.     char *ap3 = NULL, *ap4 = NULL;
  1994.     struct aclmember *entry = NULL;
  1995.     extern char *home;
  1996.     extern char chroot_path[];
  1997.     char *sp;
  1998.     int i;
  2000.     /* default is maximum throughput */
  2001.     *bps = -1;
  2002.     *bpsmult = 1.0;
  2004.     /* XXX We could use dynamic RAM to store this path, but I'd rather just bail
  2005.        out with an error. The rest of wu is so crufy that a long path might
  2006.        just blow up later */
  2008.     if ((strlen(name) + 1) > sizeof(path)) {
  2009. return;
  2010.     }
  2012.     /* what's our current directory? */
  2013.     strcpy(path, name);
  2014.     if ((sp = strrchr(path, '/')))
  2015. *sp = '';
  2016.     else
  2017. strcpy(path, ".");
  2018.     if ((sp = strrchr(name, '/')))
  2019. strcpy(file, sp + 1);
  2020.     else
  2021. strcpy(file, name);
  2022.     if ((fb_realpath(path, cwdir)) == NULL) {
  2023. return;
  2024.     }
  2026.     wu_realpath(home, pwdir, chroot_path);
  2028.     /* find best matching entry */
  2029.     while (getaclentry("throughput", &entry) && ARG0 && ARG1 && ARG2 && ARG3 && ARG4 && ARG5 != NULL) {
  2030. if ((0 < path_compare(ARG0, pwdir))
  2031.     && ((i = path_compare(ARG1, cwdir)) >= match_value)
  2032.     ) {
  2033.     if (file_compare(ARG2, file)) {
  2034. if (remote_compare(ARG5)) {
  2035.     match_value = i;
  2036.     ap3 = ARG3;
  2037.     ap4 = ARG4;
  2038. }
  2039.     }
  2040. }
  2041.     }
  2043.     /* if we did get matches */
  2044.     if (match_value >= 0) {
  2045. if (strcasecmp(ap3, "oo") == 0)
  2046.     *bps = -1;
  2047. else
  2048.     *bps = atoi(ap3);
  2049. if (strcmp(ap4, "-") == 0)
  2050.     *bpsmult = 1.0;
  2051. else
  2052.     *bpsmult = atof(ap4);
  2053.     }
  2054.     return;
  2055. }
  2057. void throughput_adjust(char *name)
  2058. {
  2059.     int match_value = -1;
  2060.     char pwdir[MAXPATHLEN];
  2061.     char cwdir[MAXPATHLEN];
  2062.     char path[MAXPATHLEN];
  2063.     char file[MAXPATHLEN];
  2064.     char buf[MAXPATHLEN];
  2065.     char *ap3 = NULL, *ap4 = NULL;
  2066.     char **pap3;
  2067.     struct aclmember *entry = NULL;
  2068.     extern char *home;
  2069.     extern char chroot_path[];
  2070.     char *sp;
  2071.     int i;
  2073.     /* XXX We could use dynamic RAM to store this path, but I'd rather just bail
  2074.        out with an error. The rest of wu is so crufy that a long path might
  2075.        just blow up later */
  2077.     if ((strlen(name) + 1) > sizeof(path)) {
  2078. return;
  2079.     }
  2081.     /* what's our current directory? */
  2082.     strcpy(path, name);
  2083.     if ((sp = strrchr(path, '/')))
  2084. *sp = '';
  2085.     else
  2086. strcpy(path, ".");
  2087.     if ((sp = strrchr(name, '/')))
  2088. strcpy(file, sp + 1);
  2089.     else
  2090. strcpy(file, name);
  2091.     if ((fb_realpath(path, cwdir)) == NULL) {
  2092. return;
  2093.     }
  2095.     wu_realpath(home, pwdir, chroot_path);
  2097.     /* find best matching entry */
  2098.     while (getaclentry("throughput", &entry) && ARG0 && ARG1 && ARG2 && ARG3 && ARG4 && ARG5 != NULL) {
  2099. if ((0 < path_compare(ARG0, pwdir))
  2100.     && ((i = path_compare(ARG1, cwdir)) >= match_value)
  2101.     ) {
  2102.     if (file_compare(ARG2, file)) {
  2103. if (remote_compare(ARG5)) {
  2104.     match_value = i;
  2105.     ap3 = ARG3;
  2106.     pap3 = &ARG3;
  2107.     ap4 = ARG4;
  2108. }
  2109.     }
  2110. }
  2111.     }
  2113.     /* if we did get matches */
  2114.     if (match_value >= 0) {
  2115. if (strcasecmp(ap3, "oo") != 0) {
  2116.     if (strcmp(ap4, "-") != 0) {
  2117. sprintf(buf, "%.0f", atoi(ap3) * atof(ap4));
  2118. *pap3 = (char *) malloc(strlen(buf) + 1);
  2119. if (*pap3 == NULL) {
  2120.     syslog(LOG_ERR, "malloc error in throughput_adjust");
  2121.     exit(0);
  2122. }
  2123. strcpy(*pap3, buf);
  2124.     }
  2125. }
  2126.     }
  2127.     return;
  2128. }
  2130. #endif
  2132. static int CheckMethod = 0;
  2134. void SetCheckMethod(const char *method)
  2135. {
  2136.     if ((strcasecmp(method, "md5") == 0)
  2137. || (strcasecmp(method, "rfc1321") == 0))
  2138. CheckMethod = 0;
  2139.     else if ((strcasecmp(method, "crc") == 0)
  2140.      || (strcasecmp(method, "posix") == 0))
  2141. CheckMethod = 1;
  2142.     else {
  2143. reply(500, "Unrecognized checksum method");
  2144. return;
  2145.     }
  2146.     switch (CheckMethod) {
  2147.     default:
  2148. reply(200, "Checksum method is now: MD5 (RFC1321)");
  2149. break;
  2150.     case 1:
  2151. reply(200, "Checksum method is now: CRC (POSIX)");
  2152. break;
  2153.     }
  2154. }
  2156. void ShowCheckMethod(void)
  2157. {
  2158.     switch (CheckMethod) {
  2159.     default:
  2160. reply(200, "Current checksum method: MD5 (RFC1321)");
  2161. break;
  2162.     case 1:
  2163. reply(200, "Current checksum method: CRC (POSIX)");
  2164. break;
  2165.     }
  2166. }
  2168. void CheckSum(char *pathname)
  2169. {
  2170.     char *cmd;
  2171.     char buf[MAXPATHLEN];
  2172.     FILE *cmdf;
  2173.     struct stat st;
  2175.     if (stat(pathname, &st) == 0) {
  2176. if ((st.st_mode & S_IFMT) != S_IFREG) {
  2177.     reply(500, "%s: not a plain file.", pathname);
  2178.     return;
  2179. }
  2180.     }
  2181.     else {
  2182. perror_reply(550, pathname);
  2183. return;
  2184.     }
  2186.     switch (CheckMethod) {
  2187.     default:
  2188. cmd = "/bin/md5sum";
  2189. break;
  2190.     case 1:
  2191. cmd = "/bin/cksum";
  2192. break;
  2193.     }
  2195.     if (strlen(cmd) + 1 + strlen(pathname) + 1 > sizeof(buf)) {
  2196. reply(500, "Pathname too long");
  2197. return;
  2198.     }
  2199.     sprintf(buf, "%s %s", cmd, pathname);
  2201.     cmdf = ftpd_popen(buf, "r", 0);
  2202.     if (!cmdf) {
  2203. perror_reply(550, cmd);
  2204.     }
  2205.     else {
  2206. if (fgets(buf, sizeof buf, cmdf)) {
  2207.     char *crptr = strchr(buf, 'n');
  2208.     if (crptr != NULL)
  2209. *crptr = '';
  2210.     reply(200, "%s", buf);
  2211. }
  2212. ftpd_pclose(cmdf);
  2213.     }
  2214. }
  2216. void CheckSumLastFile(void)
  2217. {
  2218.     extern char LastFileTransferred[];
  2220.     if (LastFileTransferred[0] == '')
  2221. reply(500, "Nothing transferred yet");
  2222.     else
  2223. CheckSum(LastFileTransferred);
  2224. }