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

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

Ftp客户端

开发平台：

Unix_Linux

access.c：源码内容
  2. /****************************************************************************  
  3.  
  4.   Copyright (c) 1999 WU-FTPD Development Group.  
  5.   All rights reserved.
  6.   
  7.   Portions Copyright (c) 1980, 1985, 1988, 1989, 1990, 1991, 1993, 1994
  8.     The Regents of the University of California.
  9.   Portions Copyright (c) 1993, 1994 Washington University in Saint Louis.
  10.   Portions Copyright (c) 1996, 1998 Berkeley Software Design, Inc.
  11.   Portions Copyright (c) 1989 Massachusetts Institute of Technology.
  12.   Portions Copyright (c) 1998 Sendmail, Inc.
  13.   Portions Copyright (c) 1983, 1995, 1996, 1997 Eric P.  Allman.
  14.   Portions Copyright (c) 1997 by Stan Barber.
  15.   Portions Copyright (c) 1997 by Kent Landfield.
  16.   Portions Copyright (c) 1991, 1992, 1993, 1994, 1995, 1996, 1997
  17.     Free Software Foundation, Inc.  
  18.  
  19.   Use and distribution of this software and its source code are governed 
  20.   by the terms and conditions of the WU-FTPD Software License ("LICENSE").
  21.  
  22.   If you did not receive a copy of the license, it may be obtained online
  23.   at http://www.wu-ftpd.org/license.html.
  24.  
  25.   $Id: access.c,v 1.28 1999/10/03 13:13:08 wuftpd Exp $
  26.  
  27. ****************************************************************************/
  28. #include "config.h"
  30. #include <stdio.h>
  31. #include <errno.h>
  32. #include <string.h>
  33. #include <stdlib.h>
  35. #ifdef HAVE_SYS_SYSLOG_H
  36. #include <sys/syslog.h>
  37. #elif defined(HAVE_SYSLOG_H) || !defined(AUTOCONF)
  38. #include <syslog.h>
  39. #endif
  41. #ifdef TIME_WITH_SYS_TIME
  42. #include <time.h>
  43. #include <sys/time.h>
  44. #elif defined(HAVE_SYS_TIME_H)
  45. #include <sys/time.h>
  46. #else
  47. #include <time.h>
  48. #endif
  50. #include <ctype.h>
  51. #include <pwd.h>
  52. #include <grp.h>
  54. #include <sys/types.h>
  55. #include <sys/stat.h>
  56. #include <sys/file.h>
  57. #include <sys/param.h>
  59. #ifdef HAVE_PATHS_H
  60. #include <paths.h>
  61. #endif
  63. #include "pathnames.h"
  64. #include "extensions.h"
  65. #include "proto.h"
  67. #if defined(HAVE_FCNTL_H)
  68. #include <fcntl.h>
  69. #endif
  71. extern char remotehost[], remoteaddr[], *remoteident, *aclbuf;
  72. extern int nameserved, anonymous, guest, TCPwindowsize, use_accessfile;
  73. extern mode_t defumask;
  74. char Shutdown[MAXPATHLEN];
  75. int keepalive = 0;
  76. #define MAXLINE 80
  77. static char incline[MAXLINE];
  78. int pidfd = -1;
  79. extern int Bypass_PID_Files;
  81. #ifndef HELP_CRACKERS
  82. extern char DelayedMessageFile[];
  83. #endif
  85. #include "wu_fnmatch.h"
  87. extern void load_timeouts(void);
  89. /*************************************************************************/
  90. /* FUNCTION  : parse_time                                                */
  91. /* PURPOSE   : Check a single valid-time-string against the current time */
  92. /*             and return whether or not a match occurs.                 */
  93. /* ARGUMENTS : a pointer to the time-string                              */
  94. /*************************************************************************/
  96. int parsetime(char *whattime)
  97. {
  98.     static char *days[] =
  99.     {"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa", "Wk"};
  100.     time_t clock;
  101.     struct tm *curtime;
  102.     int wday, start, stop, ltime, validday, loop, match;
  104.     (void) time(&clock);
  105.     curtime = localtime(&clock);
  106.     wday = curtime->tm_wday;
  107.     validday = 0;
  108.     match = 1;
  110.     while (match && isalpha(*whattime) && isupper(*whattime)) {
  111. match = 0;
  112. for (loop = 0; loop < 8; loop++) {
  113.     if (strncmp(days[loop], whattime, 2) == 0) {
  114. whattime += 2;
  115. match = 1;
  116. if ((wday == loop) || ((loop == 7) && wday && (wday < 6))) {
  117.     validday = 1;
  118. }
  119.     }
  120. }
  121.     }
  123.     if (!validday) {
  124. if (strncmp(whattime, "Any", 3) == 0) {
  125.     validday = 1;
  126.     whattime += 3;
  127. }
  128. else
  129.     return (0);
  130.     }
  132.     if (sscanf(whattime, "%d-%d", &start, &stop) == 2) {
  133. ltime = curtime->tm_min + 100 * curtime->tm_hour;
  134. if ((start < stop) && ((ltime >= start) && ltime < stop))
  135.     return (1);
  136. if ((start > stop) && ((ltime >= start) || ltime < stop))
  137.     return (1);
  138.     }
  139.     else
  140. return (1);
  142.     return (0);
  143. }
  145. /*************************************************************************/
  146. /* FUNCTION  : validtime                                                 */
  147. /* PURPOSE   : Break apart a set of valid time-strings and pass them to  */
  148. /*             parse_time, returning whether or not ANY matches occurred */
  149. /* ARGUMENTS : a pointer to the time-string                              */
  150. /*************************************************************************/
  152. int validtime(char *ptr)
  153. {
  154.     char *nextptr;
  155.     int good;
  157.     while (1) {
  158. nextptr = strchr(ptr, '|');
  159. if (strchr(ptr, '|') == NULL)
  160.     return (parsetime(ptr));
  161. *nextptr = '';
  162. good = parsetime(ptr);
  163. /* gotta restore the | or things get skipped! */
  164. *nextptr++ = '|';
  165. if (good)
  166.     return (1);
  167. ptr = nextptr;
  168.     }
  169. }
  171. /*************************************************************************/
  172. /* FUNCTION  : hostmatch                                                 */
  173. /* PURPOSE   : Match remote hostname or address against a glob string    */
  174. /* ARGUMENTS : The string to match                                       */
  175. /* RETURNS   : 0 if no match, 1 if a match occurs                        */
  176. /*************************************************************************/
  178. int hostmatch(char *addr, char *remoteaddr, char *remotehost)
  179. {
  180.     FILE *incfile;
  181.     char *ptr;
  182.     int found = 1;
  183.     int not_found = 0;
  184.     int match = 0;
  185.     int i, a[4], m[4], r[4], cidr;
  187.     if (addr == NULL)
  188. return (0);
  190.     if (*addr == '!') {
  191. found = 0;
  192. not_found = 1;
  193. addr++;
  194.     }
  196.     if (sscanf(addr, "%d.%d.%d.%d/%d", a, a + 1, a + 2, a + 3, &cidr) == 5) {
  197. m[0] = 0;
  198. m[1] = 0;
  199. m[2] = 0;
  200. m[3] = 0;
  201. if (cidr < 0)
  202.     cidr = 0;
  203. else if (cidr > 32)
  204.     cidr = 32;
  205. for (i = 0; cidr > 8; i++) {
  206.     m[i] = 255;
  207.     cidr -= 8;
  208. }
  209. switch (cidr) {
  210. case 8:
  211.     m[i] += 1;
  212. case 7:
  213.     m[i] += 2;
  214. case 6:
  215.     m[i] += 4;
  216. case 5:
  217.     m[i] += 8;
  218. case 4:
  219.     m[i] += 16;
  220. case 3:
  221.     m[i] += 32;
  222. case 2:
  223.     m[i] += 64;
  224. case 1:
  225.     m[i] += 128;
  226. }
  227. sscanf(remoteaddr, "%d.%d.%d.%d", r, r + 1, r + 2, r + 3);
  228. for (i = 0; i < 4; i++)
  229.     if ((a[i] & m[i]) != (r[i] & m[i]))
  230. return not_found;
  231. return found;
  232.     }
  233.     else if (sscanf(addr, "%d.%d.%d.%d:%d.%d.%d.%d", a, a + 1, a + 2, a + 3, m, m + 1, m + 2, m + 3) == 8) {
  234. sscanf(remoteaddr, "%d.%d.%d.%d", r, r + 1, r + 2, r + 3);
  235. for (i = 0; i < 4; i++)
  236.     if ((a[i] & m[i]) != (r[i] & m[i]))
  237. return not_found;
  238. return found;
  239.     }
  240.     else if (sscanf(addr, "%d.%d.%d.%d", a, a + 1, a + 2, a + 3) == 4) {
  241. sscanf(remoteaddr, "%d.%d.%d.%d", r, r + 1, r + 2, r + 3);
  242. for (i = 0; i < 4; i++)
  243.     if (a[i] != r[i])
  244. return not_found;
  245. return found;
  246.     }
  247.     else if (sscanf(addr, "%d.%d.%d.*", a, a + 1, a + 2) == 3) {
  248. sscanf(remoteaddr, "%d.%d.%d.%d", r, r + 1, r + 2, r + 3);
  249. for (i = 0; i < 3; i++)
  250.     if (a[i] != r[i])
  251. return not_found;
  252. return found;
  253.     }
  254.     else if (sscanf(addr, "%d.%d.*.*", a, a + 1) == 2) {
  255. sscanf(remoteaddr, "%d.%d.%d.%d", r, r + 1, r + 2, r + 3);
  256. for (i = 0; i < 2; i++)
  257.     if (a[i] != r[i])
  258. return not_found;
  259. return found;
  260.     }
  261.     else if (sscanf(addr, "%d.*.*.*", a) == 1) {
  262. sscanf(remoteaddr, "%d.%d.%d.%d", r, r + 1, r + 2, r + 3);
  263. for (i = 0; i < 1; i++)
  264.     if (a[i] != r[i])
  265. return not_found;
  266. return found;
  267.     }
  268.     else if (*addr == '/') {
  269. /*
  270.  * read addrglobs from named path using similar format as addrglobs
  271.  * in access file
  272.  */
  273. if ((incfile = fopen(addr, "r")) == NULL) {
  274.     if (errno != ENOENT)
  275. syslog(LOG_ERR,
  276.        "cannot open addrglob file %s: %m", addr);
  277.     return (0);
  278. }
  280. while (!match && (fgets(incline, MAXLINE, incfile) != NULL)) {
  281.     ptr = strtok(incline, " tn");
  282.     if (ptr && hostmatch(ptr, remoteaddr, remotehost))
  283. match = 1;
  284.     while (!match && ((ptr = strtok(NULL, " tn")) != NULL)) {
  285. if (ptr && hostmatch(ptr, remoteaddr, remotehost))
  286.     match = 1;
  287.     }
  288. }
  289. fclose(incfile);
  290. return (match ? found : not_found);
  291.     }
  292.     else { /* match a hostname or hostname glob */
  293. match = !wu_fnmatch(addr, remotehost, FNM_CASEFOLD);
  294. return (match ? found : not_found);
  295.     }
  296. }
  298. /*************************************************************************/
  299. /* FUNCTION  : acl_guestgroup                                            */
  300. /* PURPOSE   : If the real user is a member of any of the listed groups, */
  301. /*             return 1.  Otherwise return 0.                            */
  302. /* ARGUMENTS : pw, a pointer to the passwd struct for the user           */
  303. /*************************************************************************/
  305. int acl_guestgroup(struct passwd *pw)
  306. {
  307.     struct aclmember *entry = NULL;
  308.     struct group *grp;
  309.     int which;
  310.     char **member;
  312.     /*
  313.      * guestuser <name> [<name> ...]
  314.      *
  315.      * If name begins with '%' treat as numeric.
  316.      * Numeric names may be ranges.
  317.      *   %<uid>       A single numeric UID
  318.      *   %<uid>+      All UIDs greater or equal to UID
  319.      *   %<uid>-      All UIDs greater or equal to UID
  320.      *   %-<uid>      All UIDs less or equal to UID
  321.      *   %<uid>-<uid> All UIDs between the two (inclusive)
  322.      *   *            All UIDs
  323.      */
  324.     while (getaclentry("guestuser", &entry)) {
  325. for (which = 0; (which < MAXARGS) && ARG[which]; which++) {
  326.     if (!strcmp(ARG[which], "*"))
  327. return (1);
  328.     if (ARG[which][0] == '%') {
  329. char *ptr = strchr(ARG[which] + 1, '-');
  330. if (!ptr) {
  331.     ptr = strchr(ARG[which] + 1, '+');
  332.     if (!ptr) {
  333. if (pw->pw_uid == strtoul(ARG[which] + 1, NULL, 0))
  334.     return (1);
  335.     }
  336.     else {
  337. *ptr++ = '';
  338. if ((ARG[which][1] == '')
  339.     || (pw->pw_uid >= strtoul(ARG[which] + 1, NULL, 0))) {
  340.     *--ptr = '+';
  341.     return (1);
  342. }
  343. *--ptr = '+';
  344.     }
  345. }
  346. else {
  347.     *ptr++ = '';
  348.     if (((ARG[which][1] == '')
  349.  || (pw->pw_uid >= strtoul(ARG[which] + 1, NULL, 0)))
  350. && ((*ptr == '')
  351.     || (pw->pw_uid <= strtoul(ptr, NULL, 0)))) {
  352. *--ptr = '-';
  353. return (1);
  354.     }
  355.     *--ptr = '-';
  356. }
  357.     }
  358.     else {
  359. struct passwd *g_pw = getpwnam(ARG[which]);
  360. if (g_pw && (g_pw->pw_uid == pw->pw_uid))
  361.     return (1);
  362.     }
  363. }
  364.     }
  366.     /*
  367.      * guestgroup <group> [<group> ...]
  368.      *
  369.      * If group begins with '%' treat as numeric.
  370.      * Numeric groups may be ranges.
  371.      *   %<gid>       A single GID
  372.      *   %<gid>+      All GIDs greater or equal to GID
  373.      *   %<gid>-      All GIDs greater or equal to GID
  374.      *   %-<gid>      All GIDs less or equal to GID
  375.      *   %<gid>-<gid> All GIDs between the two (inclusive)
  376.      *   *            All GIDs
  377.      */
  378.     while (getaclentry("guestgroup", &entry)) {
  379. for (which = 0; (which < MAXARGS) && ARG[which]; which++) {
  380.     if (!strcmp(ARG[which], "*"))
  381. return (1);
  382.     if (ARG[which][0] == '%') {
  383. char *ptr = strchr(ARG[which] + 1, '-');
  384. if (!ptr) {
  385.     ptr = strchr(ARG[which] + 1, '+');
  386.     if (!ptr) {
  387. if (pw->pw_gid == strtoul(ARG[which] + 1, NULL, 0))
  388.     return (1);
  389.     }
  390.     else {
  391. *ptr++ = '';
  392. if ((ARG[which][1] == '')
  393.     || (pw->pw_gid >= strtoul(ARG[which] + 1, NULL, 0))) {
  394.     *--ptr = '+';
  395.     return (1);
  396. }
  397. *--ptr = '+';
  398.     }
  399. }
  400. else {
  401.     *ptr++ = '';
  402.     if (((ARG[which][1] == '')
  403.  || (pw->pw_gid >= strtoul(ARG[which] + 1, NULL, 0)))
  404. && ((*ptr == '')
  405.     || (pw->pw_gid <= strtoul(ptr, NULL, 0)))) {
  406. *--ptr = '-';
  407. return (1);
  408.     }
  409.     *--ptr = '-';
  410. }
  411.     }
  412.     else {
  413. if ((grp = getgrnam(ARG[which]))) {
  414.     if (grp->gr_gid == pw->pw_gid)
  415. return (1);
  416.     for (member = grp->gr_mem; *member; member++)
  417. if (!strcasecmp(*member, pw->pw_name))
  418.     return (1);
  419. }
  420.     }
  421. }
  422.     }
  424.     return (0);
  425. }
  427. int acl_realgroup(struct passwd *pw)
  428. {
  429.     struct aclmember *entry = NULL;
  430.     struct group *grp;
  431.     int which;
  432.     char **member;
  434.     /*
  435.      * realuser <name> [<name> ...]
  436.      *
  437.      * If name begins with '%' treat as numeric.
  438.      * Numeric names may be ranges.
  439.      *   %<uid>       A single numeric UID
  440.      *   %<uid>+      All UIDs greater or equal to UID
  441.      *   %<uid>-      All UIDs greater or equal to UID
  442.      *   %-<uid>      All UIDs less or equal to UID
  443.      *   %<uid>-<uid> All UIDs between the two (inclusive)
  444.      *   *            All UIDs
  445.      */
  446.     while (getaclentry("realuser", &entry)) {
  447. for (which = 0; (which < MAXARGS) && ARG[which]; which++) {
  448.     if (!strcmp(ARG[which], "*"))
  449. return (1);
  450.     if (ARG[which][0] == '%') {
  451. char *ptr = strchr(ARG[which] + 1, '-');
  452. if (!ptr) {
  453.     ptr = strchr(ARG[which] + 1, '+');
  454.     if (!ptr) {
  455. if (pw->pw_uid == strtoul(ARG[which] + 1, NULL, 0))
  456.     return (1);
  457.     }
  458.     else {
  459. *ptr++ = '';
  460. if ((ARG[which][1] == '')
  461.     || (pw->pw_uid >= strtoul(ARG[which] + 1, NULL, 0))) {
  462.     *--ptr = '+';
  463.     return (1);
  464. }
  465. *--ptr = '+';
  466.     }
  467. }
  468. else {
  469.     *ptr++ = '';
  470.     if (((ARG[which][1] == '')
  471.  || (pw->pw_uid >= strtoul(ARG[which] + 1, NULL, 0)))
  472. && ((*ptr == '')
  473.     || (pw->pw_uid <= strtoul(ptr, NULL, 0)))) {
  474. *--ptr = '-';
  475. return (1);
  476.     }
  477.     *--ptr = '-';
  478. }
  479.     }
  480.     else {
  481. struct passwd *g_pw = getpwnam(ARG[which]);
  482. if (g_pw && (g_pw->pw_uid == pw->pw_uid))
  483.     return (1);
  484.     }
  485. }
  486.     }
  488.     /*
  489.      * realgroup <group> [<group> ...]
  490.      *
  491.      * If group begins with '%' treat as numeric.
  492.      * Numeric groups may be ranges.
  493.      *   %<gid>       A single GID
  494.      *   %<gid>+      All GIDs greater or equal to GID
  495.      *   %<gid>-      All GIDs greater or equal to GID
  496.      *   %-<gid>      All GIDs less or equal to GID
  497.      *   %<gid>-<gid> All GIDs between the two (inclusive)
  498.      *   *            All GIDs
  499.      */
  500.     while (getaclentry("realgroup", &entry)) {
  501. for (which = 0; (which < MAXARGS) && ARG[which]; which++) {
  502.     if (!strcmp(ARG[which], "*"))
  503. return (1);
  504.     if (ARG[which][0] == '%') {
  505. char *ptr = strchr(ARG[which] + 1, '-');
  506. if (!ptr) {
  507.     ptr = strchr(ARG[which] + 1, '+');
  508.     if (!ptr) {
  509. if (pw->pw_gid == strtoul(ARG[which] + 1, NULL, 0))
  510.     return (1);
  511.     }
  512.     else {
  513. *ptr++ = '';
  514. if ((ARG[which][1] == '')
  515.     || (pw->pw_gid >= strtoul(ARG[which] + 1, NULL, 0))) {
  516.     *--ptr = '+';
  517.     return (1);
  518. }
  519. *--ptr = '+';
  520.     }
  521. }
  522. else {
  523.     *ptr++ = '';
  524.     if (((ARG[which][1] == '')
  525.  || (pw->pw_gid >= strtoul(ARG[which] + 1, NULL, 0)))
  526. && ((*ptr == '')
  527.     || (pw->pw_gid <= strtoul(ptr, NULL, 0)))) {
  528. *--ptr = '-';
  529. return (1);
  530.     }
  531.     *--ptr = '-';
  532. }
  533.     }
  534.     else {
  535. if ((grp = getgrnam(ARG[which]))) {
  536.     if (grp->gr_gid == pw->pw_gid)
  537. return (1);
  538.     for (member = grp->gr_mem; *member; member++)
  539. if (!strcasecmp(*member, pw->pw_name))
  540.     return (1);
  541. }
  542.     }
  543. }
  544.     }
  546.     return (0);
  547. }
  549. /*************************************************************************/
  550. /* FUNCTION  : acl_autogroup                                             */
  551. /* PURPOSE   : If the guest user is a member of any of the classes in    */
  552. /*             the autogroup comment, cause a setegid() to the specified */
  553. /*             group.                                                    */
  554. /* ARGUMENTS : pw, a pointer to the passwd struct for the user           */
  555. /*************************************************************************/
  557. void acl_autogroup(struct passwd *pw)
  558. {
  559.     char class[1024];
  561.     struct aclmember *entry = NULL;
  562.     struct group *grp;
  563.     int which;
  565.     (void) acl_getclass(class);
  567.     /* autogroup <group> <class> [<class> ...] */
  568.     while (getaclentry("autogroup", &entry)) {
  569. if (!ARG0 || !ARG1)
  570.     continue;
  571. for (which = 1; (which < MAXARGS) && ARG[which]; which++) {
  572.     if (!strcasecmp(ARG[which], class)) {
  573. if (ARG0[0] == '%')
  574.     pw->pw_gid = atoi(ARG0 + 1);
  575. else {
  576.     if ((grp = getgrnam(ARG0)))
  577. pw->pw_gid = grp->gr_gid;
  578.     else
  579. syslog(LOG_ERR, "autogroup: set group %s not found", ARG0);
  580.     endgrent();
  581. }
  582. return;
  583.     }
  584. }
  585.     }
  586. }
  588. /*************************************************************************/
  589. /* FUNCTION  : acl_setfunctions                                          */
  590. /* PURPOSE   : Scan the ACL buffer and determine what logging to perform */
  591. /*             for this user, and whether or not user is allowed to use  */
  592. /*             the automatic TAR and COMPRESS functions.  Also, set the  */
  593. /*             current process priority of this copy of the ftpd server  */
  594. /*             to a `nice' value value if this user is a member of a     */
  595. /*             group which the ftpaccess file says should be nice'd.     */
  596. /* ARGUMENTS : pointer to buffer to class name, pointer to ACL buffer    */
  597. /*************************************************************************/
  599. void acl_setfunctions(void)
  600. {
  601.     char class[1024];
  603.     extern int log_incoming_xfers, log_outbound_xfers, mangleopts, log_commands,
  604.         log_security, syslogmsg, lgi_failure_threshold;
  606.     struct aclmember *entry = NULL;
  608.     int l_compress, l_tar, inbound = 0, outbound = 0, which, set;
  610.     log_incoming_xfers = 0;
  611.     log_outbound_xfers = 0;
  612.     log_commands = 0;
  613.     log_security = 0;
  615.     memset((void *) &class[0], 0, sizeof(class));
  617.     (void) acl_getclass(class);
  619.     entry = (struct aclmember *) NULL;
  620.     if (getaclentry("loginfails", &entry) && ARG0 != NULL) {
  621. lgi_failure_threshold = atoi(ARG0);
  622.     }
  623. #ifndef NO_PRIVATE
  624.     entry = (struct aclmember *) NULL;
  625.     if (getaclentry("private", &entry) && !strcasecmp(ARG0, "yes"))
  626. priv_setup(_path_private);
  627. #endif /* !NO_PRIVATE */
  629.     entry = (struct aclmember *) NULL;
  630.     set = 0;
  631.     while (!set && getaclentry("compress", &entry)) {
  632. l_compress = 0;
  633. if (!strcasecmp(ARG0, "yes"))
  634.     l_compress = 1;
  635. for (which = 1; (which < MAXARGS) && ARG[which]; which++) {
  636.     if (!wu_fnmatch(ARG[which], class, FNM_CASEFOLD)) {
  637. mangleopts |= l_compress * (O_COMPRESS | O_UNCOMPRESS);
  638. set = 1;
  639.     }
  640. }
  641.     }
  643.     entry = (struct aclmember *) NULL;
  644.     set = 0;
  645.     while (!set && getaclentry("tar", &entry)) {
  646. l_tar = 0;
  647. if (!strcasecmp(ARG0, "yes"))
  648.     l_tar = 1;
  649. for (which = 1; (which < MAXARGS) && ARG[which]; which++) {
  650.     if (!wu_fnmatch(ARG[which], class, FNM_CASEFOLD)) {
  651. mangleopts |= l_tar * O_TAR;
  652. set = 1;
  653.     }
  654. }
  655.     }
  657.     /* plan on expanding command syntax to include classes for each of these */
  659.     entry = (struct aclmember *) NULL;
  660.     while (getaclentry("log", &entry)) {
  661. if (!strcasecmp(ARG0, "commands")) {
  662.     if (anonymous && strcasestr(ARG1, "anonymous"))
  663. log_commands = 1;
  664.     if (guest && strcasestr(ARG1, "guest"))
  665. log_commands = 1;
  666.     if (!guest && !anonymous && strcasestr(ARG1, "real"))
  667. log_commands = 1;
  668. }
  669. if (!strcasecmp(ARG0, "transfers")) {
  670.     set = 0;
  671.     if (strcasestr(ARG1, "anonymous") && anonymous)
  672. set = 1;
  673.     if (strcasestr(ARG1, "guest") && guest)
  674. set = 1;
  675.     if (strcasestr(ARG1, "real") && !guest && !anonymous)
  676. set = 1;
  677.     if (strcasestr(ARG2, "inbound"))
  678. inbound = 1;
  679.     if (strcasestr(ARG2, "outbound"))
  680. outbound = 1;
  681.     if (set)
  682. log_incoming_xfers = inbound;
  683.     if (set)
  684. log_outbound_xfers = outbound;
  685. }
  686. if (!strcasecmp(ARG0, "security")) {
  687.     if (strcasestr(ARG1, "anonymous") && anonymous)
  688. log_security = 1;
  689.     if (strcasestr(ARG1, "guest") && guest)
  690. log_security = 1;
  691.     if (strcasestr(ARG1, "real") && !guest && !anonymous)
  692. log_security = 1;
  693. }
  694. if (!strcasecmp(ARG0, "syslog"))
  695.     syslogmsg = 1;
  696. if (!strcasecmp(ARG0, "xferlog"))
  697.     syslogmsg = 0;
  698. if (!strcasecmp(ARG0, "syslog+xferlog")
  699.     || !strcasecmp(ARG0, "xferlog+syslog"))
  700.     syslogmsg = 2;
  701.     }
  702. }
  704. /*************************************************************************/
  705. /* FUNCTION  : acl_getclass                                              */
  706. /* PURPOSE   : Scan the ACL buffer and determine what class user is in   */
  707. /* ARGUMENTS : pointer to buffer to class name, pointer to ACL buffer    */
  708. /*************************************************************************/
  710. int acl_getclass(char *classbuf)
  711. {
  712.     int which;
  713.     struct aclmember *entry = NULL;
  715.     while (getaclentry("class", &entry)) {
  716. if (ARG0)
  717.     strcpy(classbuf, ARG0);
  719. for (which = 2; (which < MAXARGS) && ARG[which]; which++) {
  720.     if (anonymous && strcasestr(ARG1, "anonymous") &&
  721. hostmatch(ARG[which], remoteaddr, remotehost))
  722. return (1);
  724.     if (guest && strcasestr(ARG1, "guest") && hostmatch(ARG[which], remoteaddr, remotehost))
  725. return (1);
  727.     if (!guest && !anonymous && strcasestr(ARG1, "real") &&
  728. hostmatch(ARG[which], remoteaddr, remotehost))
  729. return (1);
  730. }
  731.     }
  733.     *classbuf = (char) NULL;
  734.     return (0);
  736. }
  738. /*************************************************************************/
  739. /* FUNCTION  : acl_getlimit                                              */
  740. /* PURPOSE   : Scan the ACL buffer and determine what limit applies to   */
  741. /*             the user                                                  */
  742. /* ARGUMENTS : pointer class name, pointer to ACL buffer                 */
  743. /*************************************************************************/
  745. int acl_getlimit(char *class, char *msgpathbuf)
  746. {
  747.     int limit;
  748.     struct aclmember *entry = NULL;
  750.     if (msgpathbuf)
  751. *msgpathbuf = '';
  753.     /* limit <class> <n> <times> [<message_file>] */
  754.     while (getaclentry("limit", &entry)) {
  755. if (!ARG0 || !ARG1 || !ARG2)
  756.     continue;
  757. if (!strcasecmp(class, ARG0)) {
  758.     limit = atoi(ARG1);
  759.     if (validtime(ARG2)) {
  760. if (ARG3 && msgpathbuf)
  761.     strcpy(msgpathbuf, ARG3);
  762. return (limit);
  763.     }
  764. }
  765.     }
  766.     return (-1);
  767. }
  769. /*************************************************************************/
  770. /* FUNCTION  : acl_getnice                                               */
  771. /* PURPOSE   : Scan the ACL buffer and determine what nice value applies */
  772. /*             to the user                                               */
  773. /* ARGUMENTS : pointer class name                                        */
  774. /*************************************************************************/
  776. int acl_getnice(char *class)
  777. {
  778.     int nice_delta_for_class_found = 0;
  779.     int nice_delta = 0;
  780.     int default_nice_delta = 0;
  782.     struct aclmember *entry = NULL;
  784.     /* nice <nice_delta> [<class>] */
  785.     while (getaclentry("nice", &entry)) {
  786. if (!ARG0)
  787.     continue;
  788. if (!ARG1)
  789.     default_nice_delta = atoi(ARG0);
  790. else if (!strcasecmp(class, ARG1)) {
  791.     nice_delta_for_class_found = 1;
  792.     nice_delta = atoi(ARG0);
  793. }
  794.     }
  795.     if (!nice_delta_for_class_found)
  796. nice_delta = default_nice_delta;
  797.     return nice_delta;
  798. }
  801. /*************************************************************************/
  802. /* FUNCTION  : acl_getdefumask                                           */
  803. /* PURPOSE   : Scan the ACL buffer to determine what umask value applies */
  804. /*             to the user                                               */
  805. /* ARGUMENTS : pointer to class name                                     */
  806. /*************************************************************************/
  808. void acl_getdefumask(char *class)
  809. {
  810.     struct aclmember *entry = NULL;
  812.     /* defumask <umask> [<class>] */
  813.     while (getaclentry("defumask", &entry)) {
  814. if (!ARG0)
  815.     continue;
  816. if (!ARG1)
  817.     defumask = strtoul(ARG0, NULL, 0);
  818. else if (!strcasecmp(class, ARG1)) {
  819.     defumask = strtoul(ARG0, NULL, 0);
  820.     break;
  821. }
  822.     }
  823.     umask(defumask);
  824. }
  826. /*************************************************************************/
  827. /* FUNCTION  : acl_tcpwindow                                             */
  828. /* PURPOSE   : Scan the ACL buffer and determine what TCP window size to */
  829. /*             use based upon the class                                  */
  830. /* ARGUMENTS : pointer to class name                                     */
  831. /*************************************************************************/
  833. void acl_tcpwindow(char *class)
  834. {
  835.     struct aclmember *entry = NULL;
  837.     /* tcpwindow <size> [<class>] */
  838.     while (getaclentry("tcpwindow", &entry)) {
  839. if (!ARG0)
  840.     continue;
  841. if (!ARG1)
  842.     TCPwindowsize = strtoul(ARG0, NULL, 0);
  843. else if (!strcasecmp(class, ARG1)) {
  844.     TCPwindowsize = strtoul(ARG0, NULL, 0);
  845.     break;
  846. }
  847.     }
  848. }
  850. #ifdef TRANSFER_COUNT
  851. #ifdef TRANSFER_LIMIT
  853. /*************************************************************************/
  854. /* FUNCTION  : acl_filelimit                                             */
  855. /* PURPOSE   : Scan the ACL buffer and determine what file limit to use  */
  856. /*             based upon the class                                      */
  857. /* ARGUMENTS : pointer to class name                                     */
  858. /*************************************************************************/
  860. void acl_filelimit(char *class)
  861. {
  862.     struct aclmember *entry = NULL;
  863.     int raw_in = 0;
  864.     int raw_out = 0;
  865.     int raw_total = 0;
  866.     int data_in = 0;
  867.     int data_out = 0;
  868.     int data_total = 0;
  869.     extern int file_limit_raw_in;
  870.     extern int file_limit_raw_out;
  871.     extern int file_limit_raw_total;
  872.     extern int file_limit_data_in;
  873.     extern int file_limit_data_out;
  874.     extern int file_limit_data_total;
  876.     /* file-limit [<raw>] <in|out|total> <count> [<class>] */
  877.     while (getaclentry("file-limit", &entry)) {
  878. if (!ARG0 || !ARG1)
  879.     continue;
  880. if (!strcasecmp(ARG0, "raw")) {
  881.     if (!ARG2)
  882. continue;
  883.     if (!strcasecmp(ARG1, "in")) {
  884. if (!ARG3) {
  885.     if (!raw_in)
  886. file_limit_raw_in = atoi(ARG2);
  887. }
  888. else if (!strcasecmp(class, ARG3)) {
  889.     raw_in = 1;
  890.     file_limit_raw_in = atoi(ARG2);
  891. }
  892.     }
  893.     else if (!strcasecmp(ARG1, "out")) {
  894. if (!ARG3) {
  895.     if (!raw_out)
  896. file_limit_raw_out = atoi(ARG2);
  897. }
  898. else if (!strcasecmp(class, ARG3)) {
  899.     raw_out = 1;
  900.     file_limit_raw_out = atoi(ARG2);
  901. }
  902.     }
  903.     else if (!strcasecmp(ARG1, "total")) {
  904. if (!ARG3) {
  905.     if (!raw_total)
  906. file_limit_raw_total = atoi(ARG2);
  907. }
  908. else if (!strcasecmp(class, ARG3)) {
  909.     raw_total = 1;
  910.     file_limit_raw_total = atoi(ARG2);
  911. }
  912.     }
  913. }
  914. else if (!strcasecmp(ARG0, "in")) {
  915.     if (!ARG2) {
  916. if (!data_in)
  917.     file_limit_data_in = atoi(ARG1);
  918.     }
  919.     else if (!strcasecmp(class, ARG2)) {
  920. data_in = 1;
  921. file_limit_data_in = atoi(ARG1);
  922.     }
  923. }
  924. else if (!strcasecmp(ARG0, "out")) {
  925.     if (!ARG2) {
  926. if (!data_out)
  927.     file_limit_data_out = atoi(ARG1);
  928.     }
  929.     else if (!strcasecmp(class, ARG2)) {
  930. data_out = 1;
  931. file_limit_data_out = atoi(ARG1);
  932.     }
  933. }
  934. else if (!strcasecmp(ARG0, "total")) {
  935.     if (!ARG2) {
  936. if (!data_total)
  937.     file_limit_data_total = atoi(ARG1);
  938.     }
  939.     else if (!strcasecmp(class, ARG2)) {
  940. data_total = 1;
  941. file_limit_data_total = atoi(ARG1);
  942.     }
  943. }
  944.     }
  945. }
  947. /*************************************************************************/
  948. /* FUNCTION  : acl_datalimit                                             */
  949. /* PURPOSE   : Scan the ACL buffer and determine what data limit to use  */
  950. /*             based upon the class                                      */
  951. /* ARGUMENTS : pointer to class name                                     */
  952. /*************************************************************************/
  954. void acl_datalimit(char *class)
  955. {
  956.     struct aclmember *entry = NULL;
  957.     int raw_in = 0;
  958.     int raw_out = 0;
  959.     int raw_total = 0;
  960.     int data_in = 0;
  961.     int data_out = 0;
  962.     int data_total = 0;
  963.     extern int data_limit_raw_in;
  964.     extern int data_limit_raw_out;
  965.     extern int data_limit_raw_total;
  966.     extern int data_limit_data_in;
  967.     extern int data_limit_data_out;
  968.     extern int data_limit_data_total;
  970.     /* data-limit [<raw>] <in|out|total> <count> [<class>] */
  971.     while (getaclentry("data-limit", &entry)) {
  972. if (!ARG0 || !ARG1)
  973.     continue;
  974. if (!strcasecmp(ARG0, "raw")) {
  975.     if (!ARG2)
  976. continue;
  977.     if (!strcasecmp(ARG1, "in")) {
  978. if (!ARG3) {
  979.     if (!raw_in)
  980. data_limit_raw_in = atoi(ARG2);
  981. }
  982. else if (!strcasecmp(class, ARG3)) {
  983.     raw_in = 1;
  984.     data_limit_raw_in = atoi(ARG2);
  985. }
  986.     }
  987.     else if (!strcasecmp(ARG1, "out")) {
  988. if (!ARG3) {
  989.     if (!raw_out)
  990. data_limit_raw_out = atoi(ARG2);
  991. }
  992. else if (!strcasecmp(class, ARG3)) {
  993.     raw_out = 1;
  994.     data_limit_raw_out = atoi(ARG2);
  995. }
  996.     }
  997.     else if (!strcasecmp(ARG1, "total")) {
  998. if (!ARG3) {
  999.     if (!raw_total)
  1000. data_limit_raw_total = atoi(ARG2);
  1001. }
  1002. else if (!strcasecmp(class, ARG3)) {
  1003.     raw_total = 1;
  1004.     data_limit_raw_total = atoi(ARG2);
  1005. }
  1006.     }
  1007. }
  1008. else if (!strcasecmp(ARG0, "in")) {
  1009.     if (!ARG2) {
  1010. if (!data_in)
  1011.     data_limit_data_in = atoi(ARG1);
  1012.     }
  1013.     else if (!strcasecmp(class, ARG2)) {
  1014. data_in = 1;
  1015. data_limit_data_in = atoi(ARG1);
  1016.     }
  1017. }
  1018. else if (!strcasecmp(ARG0, "out")) {
  1019.     if (!ARG2) {
  1020. if (!data_out)
  1021.     data_limit_data_out = atoi(ARG1);
  1022.     }
  1023.     else if (!strcasecmp(class, ARG2)) {
  1024. data_out = 1;
  1025. data_limit_data_out = atoi(ARG1);
  1026.     }
  1027. }
  1028. else if (!strcasecmp(ARG0, "total")) {
  1029.     if (!ARG2) {
  1030. if (!data_total)
  1031.     data_limit_data_total = atoi(ARG1);
  1032.     }
  1033.     else if (!strcasecmp(class, ARG2)) {
  1034. data_total = 1;
  1035. data_limit_data_total = atoi(ARG1);
  1036.     }
  1037. }
  1038.     }
  1039. }
  1041. #endif
  1042. #endif
  1044. /*************************************************************************/
  1045. /* FUNCTION  : acl_deny                                                  */
  1046. /* PURPOSE   : Scan the ACL buffer and determine a deny command applies  */
  1047. /* ARGUMENTS : pointer class name, pointer to ACL buffer                 */
  1048. /*************************************************************************/
  1050. int acl_deny(char *msgpathbuf)
  1051. {
  1052.     struct aclmember *entry = NULL;
  1054.     if (msgpathbuf)
  1055. *msgpathbuf = (char) NULL;
  1057.     /* deny <addrglob> [<message_file>] */
  1058.     while (getaclentry("deny", &entry)) {
  1059. if (!ARG0)
  1060.     continue;
  1061. if (strcasecmp(ARG0, "!nameserved") == 0) {
  1062.     if (!nameserved) {
  1063. if (ARG1)
  1064.     strcpy(msgpathbuf, entry->arg[1]);
  1065. return (1);
  1066.     }
  1067. }
  1068. else if (hostmatch(ARG0, remoteaddr, remotehost)) {
  1069.     if (ARG1)
  1070. strcpy(msgpathbuf, entry->arg[1]);
  1071.     return (1);
  1072. }
  1073.     }
  1074.     return (0);
  1075. }
  1077. /*************************************************************************/
  1078. /* FUNCTION  : acl_countusers                                            */
  1079. /* PURPOSE   : Check the anonymous FTP access lists to see if this       */
  1080. /*             access is permitted.                                      */
  1081. /* ARGUMENTS : none                                                      */
  1082. /*************************************************************************/
  1084. int acl_countusers(char *class)
  1085. {
  1086.     int count, which;
  1087.     char pidfile[MAXPATHLEN];
  1088.     pid_t buf[MAXUSERS];
  1089. #ifndef HAVE_FLOCK
  1090.     struct flock arg;
  1091. #endif
  1093.     if (Bypass_PID_Files)
  1094. return (0);
  1095.     /* 
  1096.      * if pidfd was not opened previously... 
  1097.      * pidfd must stay open after the chroot(~ftp)  
  1098.      */
  1100.     sprintf(pidfile, _PATH_PIDNAMES, class);
  1102.     if (pidfd < 0) {
  1103. mode_t oldmask;
  1104. oldmask = umask(0);
  1105. pidfd = open(pidfile, O_RDWR | O_CREAT, 0644);
  1106. (void) umask(oldmask);
  1107.     }
  1109.     if (pidfd < 0) {
  1110. syslog(LOG_ERR, "cannot open pid file %s: %m", pidfile);
  1111. return -1;
  1112.     }
  1114. #ifdef HAVE_FLOCK
  1115.     while (flock(pidfd, LOCK_EX)) {
  1116. #ifndef NO_PID_SLEEP_MSGS
  1117. syslog(LOG_ERR, "sleeping: flock of pid file failed: %m");
  1118. #endif
  1119. #else
  1120.     arg.l_type = F_WRLCK;
  1121.     arg.l_whence = arg.l_start = arg.l_len = 0;
  1122.     while (-1 == fcntl(pidfd, F_SETLK, &arg)) {
  1123. #ifndef NO_PID_SLEEP_MSGS
  1124. syslog(LOG_ERR, "sleeping: fcntl lock of pid file failed: %m");
  1125. #endif
  1126. #endif
  1127. sleep(1);
  1128.     }
  1129.     lseek(pidfd, (off_t) 0, SEEK_SET);
  1131.     count = 0;
  1133.     if (read(pidfd, (void *) buf, sizeof(buf)) == sizeof(buf)) {
  1134. for (which = 0; which < MAXUSERS; which++)
  1135.     if (buf[which] && !kill(buf[which], 0))
  1136. count++;
  1137.     }
  1138. #ifdef HAVE_FLOCK
  1139.     flock(pidfd, LOCK_UN);
  1140. #else
  1141.     arg.l_type = F_UNLCK;
  1142.     arg.l_whence = arg.l_start = arg.l_len = 0;
  1143.     fcntl(pidfd, F_SETLK, &arg);
  1144. #endif
  1145.     return (count);
  1146. }
  1148. /*************************************************************************/
  1149. /* FUNCTION  : acl_join                                                  */
  1150. /* PURPOSE   : Add the current process to the list of processes in the   */
  1151. /*             specified class.                                          */
  1152. /* ARGUMENTS : The name of the class to join                             */
  1153. /*************************************************************************/
  1155. void acl_join(char *class)
  1156. {
  1157.     int which, avail;
  1158.     pid_t buf[MAXUSERS];
  1159.     char pidfile[MAXPATHLEN];
  1160.     pid_t procid;
  1161. #ifndef HAVE_FLOCK
  1162.     struct flock arg;
  1163. #endif
  1165.     if (Bypass_PID_Files)
  1166. return;
  1168.     /* 
  1169.      * if pidfd was not opened previously... 
  1170.      * pidfd must stay open after the chroot(~ftp)  
  1171.      */
  1173.     sprintf(pidfile, _PATH_PIDNAMES, class);
  1175.     if (pidfd < 0) {
  1176. mode_t oldmask;
  1177. oldmask = umask(0);
  1178. pidfd = open(pidfile, O_RDWR | O_CREAT, 0644);
  1179. (void) umask(oldmask);
  1180.     }
  1182.     if (pidfd < 0) {
  1183. syslog(LOG_ERR, "cannot open pid file %s: %m", pidfile);
  1184. return;
  1185.     }
  1187. #ifdef HAVE_FLOCK
  1188.     while (flock(pidfd, LOCK_EX)) {
  1189. #ifndef NO_PID_SLEEP_MSGS
  1190. syslog(LOG_ERR, "sleeping: flock of pid file failed: %m");
  1191. #endif
  1192. #else
  1193.     arg.l_type = F_WRLCK;
  1194.     arg.l_whence = arg.l_start = arg.l_len = 0;
  1195.     while (-1 == fcntl(pidfd, F_SETLK, &arg)) {
  1196. #ifndef NO_PID_SLEEP_MSGS
  1197. syslog(LOG_ERR, "sleeping: fcntl lock of pid file failed: %m");
  1198. #endif
  1199. #endif
  1200. sleep(1);
  1201.     }
  1203.     procid = getpid();
  1205.     lseek(pidfd, (off_t) 0, SEEK_SET);
  1206.     if (read(pidfd, (void *) buf, sizeof(buf)) < sizeof(buf))
  1207. for (which = 0; which < MAXUSERS; buf[which++] = 0)
  1208.     continue;
  1210.     avail = 0;
  1211.     for (which = 0; which < MAXUSERS; which++) {
  1212. if ((buf[which] == 0) || (kill(buf[which], 0) == -1)) {
  1213.     avail = which;
  1214.     buf[which] = 0;
  1215. }
  1216. else if (buf[which] == procid) {
  1217.     /* already exists in pid file... */
  1218. #ifdef HAVE_FLOCK
  1219.     flock(pidfd, LOCK_UN);
  1220. #else
  1221.     arg.l_type = F_UNLCK;
  1222.     arg.l_whence = arg.l_start = arg.l_len = 0;
  1223.     fcntl(pidfd, F_SETLK, &arg);
  1224. #endif
  1225.     return;
  1226. }
  1227.     }
  1229.     buf[avail] = procid;
  1231.     lseek(pidfd, (off_t) 0, SEEK_SET);
  1232.     write(pidfd, (void *) buf, sizeof(buf));
  1233. #ifdef HAVE_FLOCK
  1234.     flock(pidfd, LOCK_UN);
  1235. #else
  1236.     arg.l_type = F_UNLCK;
  1237.     arg.l_whence = arg.l_start = arg.l_len = 0;
  1238.     fcntl(pidfd, F_SETLK, &arg);
  1239. #endif
  1241. }
  1243. /*************************************************************************/
  1244. /* FUNCTION  : acl_remove                                                */
  1245. /* PURPOSE   : remove the current process to the list of processes in    */
  1246. /*             the specified class.                                      */
  1247. /* ARGUMENTS : The name of the class to remove                           */
  1248. /*************************************************************************/
  1250. void acl_remove(void)
  1251. {
  1252.     char class[1024];
  1253.     int which, avail;
  1254.     pid_t buf[MAXUSERS];
  1255.     char pidfile[MAXPATHLEN];
  1256.     pid_t procid;
  1257. #ifndef HAVE_FLOCK
  1258.     struct flock arg;
  1259. #endif
  1261.     if (Bypass_PID_Files)
  1262. return;
  1264.     if (!acl_getclass(class)) {
  1265. return;
  1266.     }
  1268.     /* 
  1269.      * if pidfd was not opened previously... 
  1270.      * pidfd must stay open after the chroot(~ftp)  
  1271.      */
  1273.     sprintf(pidfile, _PATH_PIDNAMES, class);
  1275.     if (pidfd < 0) {
  1276. mode_t oldmask;
  1277. oldmask = umask(0);
  1278. pidfd = open(pidfile, O_RDWR | O_CREAT, 0644);
  1279. (void) umask(oldmask);
  1280.     }
  1282.     if (pidfd < 0) {
  1283. syslog(LOG_ERR, "cannot open pid file %s: %m", pidfile);
  1284. return;
  1285.     }
  1287. #ifdef HAVE_FLOCK
  1288.     while (flock(pidfd, LOCK_EX)) {
  1289. #ifndef NO_PID_SLEEP_MSGS
  1290. syslog(LOG_ERR, "sleeping: flock of pid file failed: %m");
  1291. #endif
  1292. #else
  1293.     arg.l_type = F_WRLCK;
  1294.     arg.l_whence = arg.l_start = arg.l_len = 0;
  1295.     while (-1 == fcntl(pidfd, F_SETLK, &arg)) {
  1296. #ifndef NO_PID_SLEEP_MSGS
  1297. syslog(LOG_ERR, "sleeping: fcntl lock of pid file failed: %m");
  1298. #endif
  1299. #endif
  1300. sleep(1);
  1301.     }
  1303.     procid = getpid();
  1305.     lseek(pidfd, (off_t) 0, SEEK_SET);
  1306.     if (read(pidfd, (void *) buf, sizeof(buf)) < sizeof(buf))
  1307. for (which = 0; which < MAXUSERS; buf[which++] = 0)
  1308.     continue;
  1310.     avail = 0;
  1311.     for (which = 0; which < MAXUSERS; which++) {
  1312. if ((buf[which] == 0) || (kill(buf[which], 0) == -1)) {
  1313.     avail = which;
  1314.     buf[which] = 0;
  1315. }
  1316. else if (buf[which] == procid) {
  1317.     buf[which] = 0;
  1318. }
  1319.     }
  1321.     lseek(pidfd, (off_t) 0, SEEK_SET);
  1322.     write(pidfd, (void *) buf, sizeof(buf));
  1323. #ifdef HAVE_FLOCK
  1324.     flock(pidfd, LOCK_UN);
  1325. #else
  1326.     arg.l_type = F_UNLCK;
  1327.     arg.l_whence = arg.l_start = arg.l_len = 0;
  1328.     fcntl(pidfd, F_SETLK, &arg);
  1329. #endif
  1331.     close(pidfd);
  1332.     pidfd = -1;
  1333. }
  1335. /*************************************************************************/
  1336. /* FUNCTION  : pr_mesg                                                   */
  1337. /* PURPOSE   : Display a message to the user                             */
  1338. /* ARGUMENTS : message code, name of file to display                     */
  1339. /*************************************************************************/
  1341. void pr_mesg(int msgcode, char *msgfile)
  1342. {
  1343.     FILE *infile;
  1344.     char inbuf[1024], outbuf[1024], *cr;
  1346.     if (msgfile && (int) strlen(msgfile) > 0) {
  1347. infile = fopen(msgfile, "r");
  1348. if (infile) {
  1349.     while (fgets(inbuf, sizeof(inbuf), infile) != NULL) {
  1350. if ((cr = strchr(inbuf, 'n')) != NULL)
  1351.     *cr = '';
  1352. msg_massage(inbuf, outbuf, sizeof(outbuf));
  1353. lreply(msgcode, "%s", outbuf);
  1354.     }
  1355.     fclose(infile);
  1356. }
  1357.     }
  1358. }
  1360. /*************************************************************************/
  1361. /* FUNCTION  : access_init                                               */
  1362. /* PURPOSE   : Read and parse the access lists to set things up          */
  1363. /* ARGUMENTS : none                                                      */
  1364. /*************************************************************************/
  1366. void access_init(void)
  1367. {
  1368.     struct aclmember *entry;
  1370.     if (!readacl(_path_ftpaccess))
  1371. return;
  1372.     (void) parseacl();
  1374.     Shutdown[0] = '';
  1375.     entry = (struct aclmember *) NULL;
  1376.     if (getaclentry("shutdown", &entry) && ARG0 != NULL)
  1377. (void) strncpy(Shutdown, ARG0, sizeof(Shutdown));
  1378.     entry = (struct aclmember *) NULL;
  1379.     if (getaclentry("keepalive", &entry) && ARG0 != NULL)
  1380. if (!strcasecmp(ARG0, "yes"))
  1381.     keepalive = 1;
  1382.     load_timeouts();
  1383. }
  1385. /*************************************************************************/
  1386. /* FUNCTION  : access_ok                                                 */
  1387. /* PURPOSE   : Check the anonymous FTP access lists to see if this       */
  1388. /*             access is permitted.                                      */
  1389. /* ARGUMENTS : none                                                      */
  1390. /*************************************************************************/
  1392. int access_ok(int msgcode)
  1393. {
  1394.     char class[1024], msgfile[MAXPATHLEN];
  1395.     int limit;
  1396.     int nice_delta;
  1398.     if (!use_accessfile)
  1399. return (1);
  1401.     if (aclbuf == NULL) {
  1402. syslog(LOG_NOTICE,
  1403.        "ACCESS DENIED (error reading access file) TO %s",
  1404.        remoteident);
  1405. return (0);
  1406.     }
  1407.     if (acl_deny(msgfile)) {
  1408. #ifndef HELP_CRACKERS
  1409. memcpy(DelayedMessageFile, msgfile, sizeof(msgfile));
  1410. #else
  1411. pr_mesg(msgcode, msgfile);
  1412. #endif
  1413. syslog(LOG_NOTICE, "ACCESS DENIED (deny command) TO %s",
  1414.        remoteident);
  1415. return (0);
  1416.     }
  1417.     /* if user is not in any class, deny access */
  1418.     if (!acl_getclass(class)) {
  1419. syslog(LOG_NOTICE, "ACCESS DENIED (not in any class) TO %s",
  1420.        remoteident);
  1421. return (0);
  1422.     }
  1423.     if ((nice_delta = acl_getnice(class))) {
  1424. if (nice_delta < 0)
  1425.     syslog(LOG_NOTICE, "Process nice value adjusted by %d", nice_delta);
  1426. nice(nice_delta);
  1427.     }
  1428.     acl_getdefumask(class);
  1429.     acl_tcpwindow(class);
  1430. #ifdef TRANSFER_COUNT
  1431. #ifdef TRANSFER_LIMIT
  1432.     acl_filelimit(class);
  1433.     acl_datalimit(class);
  1434. #endif
  1435. #endif
  1436.     /* if no limits defined, no limits apply -- access OK */
  1437.     limit = acl_getlimit(class, msgfile);
  1439.     if ((limit == -1) || (acl_countusers(class) < limit)) {
  1440. acl_join(class);
  1441. return (1);
  1442.     }
  1443.     else {
  1444. #ifdef LOG_TOOMANY
  1445. syslog(LOG_NOTICE, "ACCESS DENIED (user limit %d; class %s) TO %s",
  1446.        limit, class, remoteident);
  1447. #endif
  1448. #ifndef HELP_CRACKERS
  1449. memcpy(DelayedMessageFile, msgfile, sizeof(msgfile));
  1450. #else
  1451. pr_mesg(msgcode, msgfile);
  1452. #endif
  1453. return (-1);
  1454.     }
  1456.     /* NOTREACHED */
  1457. }