PageRenderTime 59ms CodeModel.GetById 22ms RepoModel.GetById 1ms app.codeStats 0ms

/usr/src/cmd/cmd-inet/usr.sbin/in.ftpd/extensions.c

https://bitbucket.org/buffyg/illumos-gate-1514
C | 2365 lines | 1969 code | 231 blank | 165 comment | 735 complexity | 534ee11a1b57c953a4e176b2dcf1beca MD5 | raw file
Possible License(s): BSD-3-Clause-No-Nuclear-License-2014, MPL-2.0-no-copyleft-exception, AGPL-3.0, GPL-2.0, GPL-3.0, LGPL-3.0, 0BSD, AGPL-1.0, BSD-3-Clause, LGPL-2.1, LGPL-2.0, BSD-2-Clause

Large files files are truncated, but you can click here to view the full file

    

  1. /*
    2. 

  2.  * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
    3. 

  3.  */
    4. 

  4. 

  5. /****************************************************************************  
    6. 

  6.  
    7. 

  7.   Copyright (c) 1999,2000 WU-FTPD Development Group.  
    8. 

  8.   All rights reserved.
    9. 

  9.   
    10. 

  10.   Portions Copyright (c) 1980, 1985, 1988, 1989, 1990, 1991, 1993, 1994
    11. 

  11.     The Regents of the University of California.
    12. 

  12.   Portions Copyright (c) 1993, 1994 Washington University in Saint Louis.
    13. 

  13.   Portions Copyright (c) 1996, 1998 Berkeley Software Design, Inc.
    14. 

  14.   Portions Copyright (c) 1989 Massachusetts Institute of Technology.
    15. 

  15.   Portions Copyright (c) 1998 Sendmail, Inc.
    16. 

  16.   Portions Copyright (c) 1983, 1995, 1996, 1997 Eric P.  Allman.
    17. 

  17.   Portions Copyright (c) 1997 by Stan Barber.
    18. 

  18.   Portions Copyright (c) 1997 by Kent Landfield.
    19. 

  19.   Portions Copyright (c) 1991, 1992, 1993, 1994, 1995, 1996, 1997
    20. 

  20.     Free Software Foundation, Inc.  
    21. 

  21.  
    22. 

  22.   Use and distribution of this software and its source code are governed 
    23. 

  23.   by the terms and conditions of the WU-FTPD Software License ("LICENSE").
    24. 

  24.  
    25. 

  25.   If you did not receive a copy of the license, it may be obtained online
    26. 

  26.   at http://www.wu-ftpd.org/license.html.
    27. 

  27.  
    28. 

  28.   $Id: extensions.c,v 1.48 2000/07/01 18:17:38 wuftpd Exp $
    29. 

  29.  
    30. 

  30. ****************************************************************************/
    31. 

  31. #include "config.h"
    32. 

  32. 

  33. #include <stdio.h>
    34. 

  34. #include <errno.h>
    35. 

  35. #include <string.h>
    36. 

  36. 

  37. #ifdef HAVE_SYS_SYSLOG_H
    38. 

  38. #include <sys/syslog.h>
    39. 

  39. #endif
    40. 

  40. #if defined(HAVE_SYSLOG_H) || (!defined(AUTOCONF) && !defined(HAVE_SYS_SYSLOG_H))
    41. 

  41. #include <syslog.h>
    42. 

  42. #endif
    43. 

  43. 

  44. #ifdef TIME_WITH_SYS_TIME
    45. 

  45. #include <time.h>
    46. 

  46. #include <sys/time.h>
    47. 

  47. #else
    48. 

  48. #ifdef HAVE_SYS_TIME_H
    49. 

  49. #include <sys/time.h>
    50. 

  50. #else
    51. 

  51. #include <time.h>
    52. 

  52. #endif
    53. 

  53. #endif
    54. 

  54. #include <pwd.h>
    55. 

  55. #include <setjmp.h>
    56. 

  56. #include <grp.h>
    57. 

  57. 

  58. #include <sys/types.h>
    59. 

  59. #include <sys/stat.h>
    60. 

  60. #include <sys/file.h>
    61. 

  61. #include <sys/param.h>
    62. 

  62. 

  63. #ifdef HAVE_SYS_FS_UFS_QUOTA_H
    64. 

  64. #include <sys/fs/ufs_quota.h>
    65. 

  65. #elif defined(HAVE_UFS_UFS_QUOTA_H)
    66. 

  66. #include <ufs/ufs/quota.h>
    67. 

  67. #elif defined(HAVE_UFS_QUOTA_H)
    68. 

  68. #include <ufs/quota.h>
    69. 

  69. #elif defined(HAVE_SYS_MNTENT_H)
    70. 

  70. #include <sys/mntent.h>
    71. 

  71. #elif defined(HAVE_SYS_MNTTAB_H)
    72. 

  72. #include <sys/mnttab.h>
    73. 

  73. #endif
    74. 

  74. 

  75. #if defined(HAVE_STATVFS)
    76. 

  76. #include <sys/statvfs.h>
    77. 

  77. #elif defined(HAVE_SYS_VFS)
    78. 

  78. #include <sys/vfs.h>
    79. 

  79. #elif defined(HAVE_SYS_MOUNT)
    80. 

  80. #include <sys/mount.h>
    81. 

  81. #endif
    82. 

  82. 

  83. #include <arpa/ftp.h>
    84. 

  84. 

  85. #ifdef HAVE_PATHS_H
    86. 

  86. #include <paths.h>
    87. 

  87. #endif
    88. 

  88. #include "pathnames.h"
    89. 

  89. #include "extensions.h"
    90. 

  90. #include "wu_fnmatch.h"
    91. 

  91. #include "proto.h"
    92. 

  92. 

  93. #if defined(HAVE_FTW)
    94. 

  94. #include <ftw.h>
    95. 

  95. #else
    96. 

  96. #include "support/ftw.h"
    97. 

  97. #endif
    98. 

  98. 

  99. #ifdef QUOTA
    100. 

  100. struct dqblk quota;
    101. 

  101. char *time_quota(long curstate, long softlimit, long timelimit, char *timeleft);
    102. 

  102. #endif
    103. 

  103. 

  104. #ifdef HAVE_REGEX_H
    105. 

  105. #include <regex.h>
    106. 

  106. #endif
    107. 

  107. 

  108. #if defined(HAVE_REGEX) && defined(SVR4) && ! (defined(NO_LIBGEN))
    109. 

  109. #include <libgen.h>
    110. 

  110. #endif
    111. 

  111. 

  112. extern int type, transflag, ftwflag, authenticated, autospout_free, data,
    113. 

  113.     pdata, anonymous, guest;
    114. 

  114. extern char chroot_path[], guestpw[];
    115. 

  115. 

  116. #ifdef TRANSFER_COUNT
    117. 

  117. extern off_t data_count_in;
    118. 

  118. extern off_t data_count_out;
    119. 

  119. #ifdef TRANSFER_LIMIT  
    120. 

  120. extern off_t data_limit_raw_in;
    121. 

  121. extern off_t data_limit_raw_out;
    122. 

  122. extern off_t data_limit_raw_total;
    123. 

  123. extern off_t data_limit_data_in;  
    124. 

  124. extern off_t data_limit_data_out; 
    125. 

  125. extern off_t data_limit_data_total;
    126. 

  126. #ifdef RATIO /* 1998/08/06 K.Wakui */
    127. 

  127. #define TRUNC_KB(n)   ((n)/1024+(((n)%1024)?1:0))
    128. 

  128. extern time_t	login_time;
    129. 

  129. extern time_t	limit_time;
    130. 

  130. extern off_t    total_free_dl;
    131. 

  131. extern int      upload_download_rate;
    132. 

  132. #endif /* RATIO */
    133. 

  133. #endif
    134. 

  134. #endif
    135. 

  135. 

  136. #ifdef OTHER_PASSWD
    137. 

  137. #include "getpwnam.h"
    138. 

  138. extern char _path_passwd[];
    139. 

  139. #endif
    140. 

  140. 

  141. #ifdef LOG_FAILED
    142. 

  142. extern char the_user[];
    143. 

  143. #endif
    144. 

  144. 

  145. extern char *globerr, remotehost[];
    146. 

  146. #ifdef THROUGHPUT
    147. 

  147. extern char remoteaddr[];
    148. 

  148. #endif
    149. 

  149. 

  150. #ifndef HAVE_REGEX
    151. 

  151. char *re_comp(const char *regex);
    152. 

  152. int re_exec(const char *p1);
    153. 

  153. #endif
    154. 

  154. 

  155. char shuttime[30], denytime[30], disctime[30];
    156. 

  156. 

  157. FILE *dout;
    158. 

  158. 

  159. time_t newer_time;
    160. 

  160. 

  161. int show_fullinfo;
    162. 

  162. 

  163. /* This always was a bug, because neither st_size nor time_t were required to
    164. 

  164.    be compatible with int, but needs fixing properly for C9X. */
    165. 

  165. 

  166. /* Some systems use one format, some another.  This takes care of the garbage */
    167. 

  167. /* Do the system specific stuff only if we aren't autoconfed */
    168. 

  168. #if !defined(L_FORMAT)
    169. 

  169. #if (defined(BSD) && (BSD >= 199103)) && !defined(LONGOFF_T)
    170. 

  170. #define L_FORMAT "qd"
    171. 

  171. #else
    172. 

  172. #define L_FORMAT "d"
    173. 

  173. #endif
    174. 

  174. #endif
    175. 

  175. #if !defined(T_FORMAT)
    176. 

  176. #define T_FORMAT "d"
    177. 

  177. #endif
    178. 

  178. #if !defined(PW_UID_FORMAT)
    179. 

  179. #define PW_UID_FORMAT "d"
    180. 

  180. #endif
    181. 

  181. #if !defined(GR_GID_FORMAT)
    182. 

  182. #define GR_GID_FORMAT "d"
    183. 

  183. #endif
    184. 

  184. 

  185. int snprintf(char *str, size_t count, const char *fmt,...);
    186. 

  186. 

  187. #ifdef SITE_NEWER
    188. 

  188. int check_newer(const char *path, const struct stat *st, int flag)
    189. 

  189. {
    190. 

  190.     if (st->st_mtime > newer_time) {
    191. 

  191. 	if (show_fullinfo != 0) {
    192. 

  192. 	    if (flag == FTW_F || flag == FTW_D) {
    193. 

  193. 		fprintf(dout, "%s %" L_FORMAT " %" T_FORMAT " %s\n",
    194. 

  194. 			flag == FTW_F ? "F" : "D",
    195. 

  195. 			st->st_size, st->st_mtime, path);
    196. 

  196. 	    }
    197. 

  197. 	}
    198. 

  198. 	else if (flag == FTW_F)
    199. 

  199. 	    fprintf(dout, "%s\n", path);
    200. 

  200.     }
    201. 

  201. 

  202.     /* When an ABOR has been received (which sets ftwflag > 1) return a
    203. 

  203.      * non-zero value which causes ftw to stop tree traversal and return. 
    204. 

  204.      */
    205. 

  205. 

  206.     return (ftwflag > 1 ? 1 : 0);
    207. 

  207. }
    208. 

  208. #endif
    209. 

  209. 

  210. #if defined(HAVE_STATVFS)
    211. 

  211. long getSize(char *s)
    212. 

  212. {
    213. 

  213.     struct statvfs buf;
    214. 

  214. 

  215.     if (statvfs(s, &buf) != 0)
    216. 

  216. 	return (0);
    217. 

  217. 

  218.     return (buf.f_bavail * buf.f_frsize / 1024);
    219. 

  219. }
    220. 

  220. #elif defined(HAVE_SYS_VFS) || defined (HAVE_SYS_MOUNT)
    221. 

  221. long getSize(char *s)
    222. 

  222. {
    223. 

  223.     struct statfs buf;
    224. 

  224. 

  225.     if (statfs(s, &buf) != 0)
    226. 

  226. 	return (0);
    227. 

  227. 

  228.     return (buf.f_bavail * buf.f_bsize / 1024);
    229. 

  229. }
    230. 

  230. #endif
    231. 

  231. 

  232. /*************************************************************************/
    233. 

  233. /* FUNCTION  : msg_massage                                               */
    234. 

  234. /* PURPOSE   : Scan a message line for magic cookies, replacing them as  */
    235. 

  235. /*             needed.                                                   */
    236. 

  236. /* ARGUMENTS : pointer input and output buffers                          */
    237. 

  237. /*************************************************************************/
    238. 

  238. 

  239. void msg_massage(const char *inbuf, char *outbuf, size_t outlen)
    240. 

  240. {
    241. 

  241.     const char *inptr = inbuf;
    242. 

  242.     char *outptr = outbuf;
    243. 

  243. #ifdef QUOTA
    244. 

  244.     char timeleft[80];
    245. 

  245. #endif
    246. 

  246.     char buffer[MAXPATHLEN];
    247. 

  247.     time_t curtime;
    248. 

  248.     int limit;
    249. 

  249. #ifndef LOG_FAILED
    250. 

  250.     extern struct passwd *pw;
    251. 

  251. #endif
    252. 

  252.     struct aclmember *entry;
    253. 

  253. 

  254. #ifdef VIRTUAL
    255. 

  255.     extern int virtual_mode;
    256. 

  256.     extern int virtual_ftpaccess;
    257. 

  257.     extern char virtual_email[];
    258. 

  258. #endif
    259. 

  259.     extern char hostname[];
    260. 

  260.     extern char authuser[];
    261. 

  261. 

  262.     (void) acl_getclass(buffer);
    263. 

  263.     limit = acl_getlimit(buffer, NULL);
    264. 

  264. 

  265.     while ((outlen > 1) && (*inptr != '\0')) {
    266. 

  266. 	if (*inptr != '%') {
    267. 

  267. 	    *outptr++ = *inptr;
    268. 

  268. 	    outlen -= 1;
    269. 

  269. 	}
    270. 

  270. 	else {
    271. 

  271. 	    entry = NULL;
    272. 

  272. 	    switch (*++inptr) {
    273. 

  273. 	    case 'E':
    274. 

  274. #ifdef VIRTUAL
    275. 

  275. 		if (virtual_mode && !virtual_ftpaccess && virtual_email[0] != '\0')
    276. 

  276. 		    snprintf(outptr, outlen, "%s", virtual_email);
    277. 

  277. 		else
    278. 

  278. #endif
    279. 

  279. 		if ((getaclentry("email", &entry)) && ARG0)
    280. 

  280. 		    snprintf(outptr, outlen, "%s", ARG0);
    281. 

  281. 		else
    282. 

  282. 		    *outptr = '\0';
    283. 

  283. 		break;
    284. 

  284. 

  285. 	    case 'N':
    286. 

  286. 		snprintf(outptr, outlen, "%d", acl_countusers(buffer));
    287. 

  287. 		break;
    288. 

  288. 

  289. 	    case 'M':
    290. 

  290. 		if (limit == -1)
    291. 

  291. 		    strncpy(outptr, "unlimited", outlen);
    292. 

  292. 		else
    293. 

  293. 		    snprintf(outptr, outlen, "%d", limit);
    294. 

  294. 		break;
    295. 

  295. 

  296. 	    case 'T':
    297. 

  297. 		(void) time(&curtime);
    298. 

  298. 		strncpy(outptr, ctime(&curtime), outlen);
    299. 

  299. 		if (outlen > 24)
    300. 

  300. 		    *(outptr + 24) = '\0';
    301. 

  301. 		break;
    302. 

  302. 

  303. 	    case 'F':
    304. 

  304. #if defined(HAVE_STATVFS) || defined(HAVE_SYS_VFS) || defined(HAVE_SYS_MOUNT)
    305. 

  305. 		snprintf(outptr, outlen, "%lu", (long) getSize("."));
    306. 

  306. #else
    307. 

  307. 		*outptr = '\0';
    308. 

  308. #endif
    309. 

  309. 		break;
    310. 

  310. 

  311. 	    case 'C':
    312. 

  312. #ifdef HAVE_GETCWD
    313. 

  313. 		(void) getcwd(outptr, outlen);
    314. 

  314. #else
    315. 

  315. #error	wu-ftpd on this platform has security deficiencies!!!
    316. 

  316. 		(void) getwd(outptr);
    317. 

  317. #endif
    318. 

  318. 		break;
    319. 

  319. 

  320. 	    case 'R':
    321. 

  321. 		strncpy(outptr, remotehost, outlen);
    322. 

  322. 		break;
    323. 

  323. 

  324. 	    case 'L':
    325. 

  325. 		strncpy(outptr, hostname, outlen);
    326. 

  326. 		break;
    327. 

  327. 

  328. 	    case 'U':
    329. 

  329. 		if (xferdone && anonymous)
    330. 

  330. 		    strncpy(outptr, guestpw, outlen);
    331. 

  331. 		else
    332. 

  332. #ifdef LOG_FAILED
    333. 

  333. 		    strncpy(outptr, the_user, outlen);
    334. 

  334. #else /* LOG_FAILED */
    335. 

  335. 		    strncpy(outptr,
    336. 

  336. 			    (pw == NULL) ? "[unknown]" : pw->pw_name, outlen);
    337. 

  337. #endif /* LOG_FAILED */
    338. 

  338. 		break;
    339. 

  339. 

  340. 	    case 's':
    341. 

  341. 		strncpy(outptr, shuttime, outlen);
    342. 

  342. 		if (outlen > 24)
    343. 

  343. 		    *(outptr + 24) = '\0';
    344. 

  344. 		break;
    345. 

  345. 

  346. 	    case 'd':
    347. 

  347. 		strncpy(outptr, disctime, outlen);
    348. 

  348. 		if (outlen > 24)
    349. 

  349. 		    *(outptr + 24) = '\0';
    350. 

  350. 		break;
    351. 

  351. 

  352. 	    case 'r':
    353. 

  353. 		strncpy(outptr, denytime, outlen);
    354. 

  354. 		if (outlen > 24)
    355. 

  355. 		    *(outptr + 24) = '\0';
    356. 

  356. 		break;
    357. 

  357. 

  358. /* KH : cookie %u for RFC931 name */
    359. 

  359. 	    case 'u':
    360. 

  360. 		if (authenticated)
    361. 

  361. 		    strncpy(outptr, authuser, outlen);
    362. 

  362. 		else {
    363. 

  363. 		    if (xferdone)
    364. 

  364. 			snprintf(outptr, outlen, "%c", '*');
    365. 

  365. 		    else
    366. 

  366. 			strncpy(outptr, "[unknown]", outlen);
    367. 

  367. 		}
    368. 

  368. 		break;
    369. 

  369. 

  370. #ifdef QUOTA
    371. 

  371. 	    case 'B':
    372. 

  372. #ifdef QUOTA_BLOCKS		/* 1024-blocks instead of 512-blocks */
    373. 

  373. 		snprintf(outptr, outlen, "%ld", quota.dqb_bhardlimit % 2 ?
    374. 

  374. 			 (long) (quota.dqb_bhardlimit / 2 + 1) : (long) (quota.dqb_bhardlimit / 2));
    375. 

  375. #else
    376. 

  376. 		snprintf(outptr, outlen, "%ld", (long) quota.dqb_bhardlimit);
    377. 

  377. #endif
    378. 

  378. 		break;
    379. 

  379. 

  380. 	    case 'b':
    381. 

  381. #ifdef QUOTA_BLOCKS		/* 1024-blocks instead of 512-blocks */
    382. 

  382. 		snprintf(outptr, outlen, "%ld", quota.dqb_bsoftlimit % 2 ?
    383. 

  383. 			 (long) (quota.dqb_bsoftlimit / 2 + 1) : (long) (quota.dqb_bsoftlimit / 2));
    384. 

  384. #else
    385. 

  385. 		snprintf(outptr, outlen, "%ld", (long) quota.dqb_bsoftlimit);
    386. 

  386. #endif
    387. 

  387. 		break;
    388. 

  388. 

  389. 	    case 'Q':
    390. 

  390. #ifdef QUOTA_BLOCKS		/* 1024-blocks instead of 512-blocks */
    391. 

  391. 		snprintf(outptr, outlen, "%ld", quota.dqb_curblocks % 2 ?
    392. 

  392. 			 (long) (quota.dqb_curblocks / 2 + 1) : (long) (quota.dqb_curblocks / 2));
    393. 

  393. #else
    394. 

  394. 		snprintf(outptr, outlen, "%ld", quota.dqb_curblocks);
    395. 

  395. #endif
    396. 

  396. 		break;
    397. 

  397. 

  398. 	    case 'I':
    399. 

  399. #if defined(QUOTA_INODE)
    400. 

  400. 		snprintf(outptr, outlen, "%d", quota.dqb_ihardlimit);
    401. 

  401. #else
    402. 

  402. 		snprintf(outptr, outlen, "%ld", (long) quota.dqb_fhardlimit);
    403. 

  403. #endif
    404. 

  404. 		break;
    405. 

  405. 

  406. 	    case 'i':
    407. 

  407. #if defined(QUOTA_INODE)
    408. 

  408. 		snprintf(outptr, outlen, "%d", quota.dqb_isoftlimit);
    409. 

  409. #else
    410. 

  410. 		snprintf(outptr, outlen, "%ld", (long) quota.dqb_fsoftlimit);
    411. 

  411. #endif
    412. 

  412. 		break;
    413. 

  413. 

  414. 	    case 'q':
    415. 

  415. #if defined(QUOTA_INODE)
    416. 

  416. 		snprintf(outptr, outlen, "%d", quota.dqb_curinodes);
    417. 

  417. #else
    418. 

  418. 		snprintf(outptr, outlen, "%ld", (long) quota.dqb_curfiles);
    419. 

  419. #endif
    420. 

  420. 		break;
    421. 

  421. 

  422. 	    case 'H':
    423. 

  423. 		time_quota(quota.dqb_curblocks, quota.dqb_bsoftlimit,
    424. 

  424. #if defined(QUOTA_INODE)
    425. 

  425. 			   quota.dqb_btime, timeleft);
    426. 

  426. #else
    427. 

  427. 			   quota.dqb_btimelimit, timeleft);
    428. 

  428. #endif
    429. 

  429. 		strncpy(outptr, timeleft, outlen);
    430. 

  430. 		break;
    431. 

  431. 

  432. 	    case 'h':
    433. 

  433. #if defined(QUOTA_INODE)
    434. 

  434. 		time_quota(quota.dqb_curinodes, quota.dqb_isoftlimit,
    435. 

  435. 			   quota.dqb_itime, timeleft);
    436. 

  436. #else
    437. 

  437. 		time_quota(quota.dqb_curfiles, quota.dqb_fsoftlimit,
    438. 

  438. 			   quota.dqb_ftimelimit, timeleft);
    439. 

  439. #endif
    440. 

  440. 		strncpy(outptr, timeleft, outlen);
    441. 

  441. 		break;
    442. 

  442. #endif /* QUOTA */
    443. 

  443. 

  444. 	    case '%':
    445. 

  445. 		*outptr++ = '%';
    446. 

  446. 		outlen -= 1;
    447. 

  447. 		*outptr = '\0';
    448. 

  448. 		break;
    449. 

  449. 

  450. #ifdef TRANSFER_COUNT
    451. 

  451. #ifdef TRANSFER_LIMIT
    452. 

  452. #ifdef RATIO
    453. 

  453.             case 'x':
    454. 

  454.                 switch (*++inptr) {
    455. 

  455.                 case 'u':       /* upload bytes */
    456. 

  456.                     sprintf(outptr,"%" L_FORMAT, TRUNC_KB(data_count_in) );
    457. 

  457.                     break;
    458. 

  458.                 case 'd':       /* download bytes */
    459. 

  459.                     sprintf(outptr,"%" L_FORMAT, TRUNC_KB(data_count_out) );
    460. 

  460.                     break;
    461. 

  461.                 case 'R':       /* rate 1:n */
    462. 

  462.                     if( upload_download_rate > 0 ) {
    463. 

  463.                         sprintf(outptr,"%d", upload_download_rate );
    464. 

  464.                     }
    465. 

  465.                     else {
    466. 

  466.                         strcpy(outptr,"free");
    467. 

  467.                     }
    468. 

  468.                     break;
    469. 

  469.                 case 'c':       /* credit bytes */
    470. 

  470.                     if( upload_download_rate > 0 ) {
    471. 

  471.                         off_t credit=( data_count_in * upload_download_rate) - (data_count_out - total_free_dl);
    472. 

  472.                         sprintf(outptr,"%" L_FORMAT, TRUNC_KB(credit) );
    473. 

  473.                     }
    474. 

  474.                     else {
    475. 

  475.                         strcpy(outptr,"unlimited");
    476. 

  476.                     }
    477. 

  477.                     break;
    478. 

  478.                 case 'T':       /* time limit (minutes) */
    479. 

  479.                     if( limit_time > 0 ) {
    480. 

  480.                         sprintf(outptr,"%d", limit_time );
    481. 

  481.                     }
    482. 

  482.                     else {
    483. 

  483.                         strcpy(outptr,"unlimited");
    484. 

  484.                     }
    485. 

  485.                     break;
    486. 

  486.                 case 'E':       /* elapsed time from loggedin (minutes) */
    487. 

  487.                     sprintf(outptr,"%d", (time(NULL)-login_time)/60 );
    488. 

  488.                     break;
    489. 

  489.                 case 'L':       /* times left until force logout (minutes) */
    490. 

  490.                     if( limit_time > 0 ) {
    491. 

  491.                         sprintf(outptr,"%d", limit_time-(time(NULL)-login_time)/60 );
    492. 

  492.                     }
    493. 

  493.                     else {
    494. 

  494.                         strcpy(outptr,"unlimited");
    495. 

  495.                     }
    496. 

  496.                     break;
    497. 

  497.                 case 'U':       /* upload limit */
    498. 

  498. 		    if( data_limit_raw_in > 0 ) {
    499. 

  499. 			sprintf(outptr,"%" L_FORMAT, TRUNC_KB(data_limit_raw_in));
    500. 

  500. 		    }
    501. 

  501. 		    else if( data_limit_data_in > 0 ) {
    502. 

  502. 			sprintf(outptr,"%" L_FORMAT, TRUNC_KB(data_limit_data_in));
    503. 

  503. 		    }
    504. 

  504. 		    else if( data_limit_raw_total > 0 ) {
    505. 

  505. 			sprintf(outptr,"%" L_FORMAT, TRUNC_KB(data_limit_raw_total));
    506. 

  506. 		    }
    507. 

  507. 		    else if( data_limit_data_total > 0 ) {
    508. 

  508. 			sprintf(outptr,"%" L_FORMAT, TRUNC_KB(data_limit_data_total));
    509. 

  509. 		    }
    510. 

  510. 		    else {
    511. 

  511. 			strcpy(outptr, "unlimited");
    512. 

  512. 		    }
    513. 

  513.                     break;
    514. 

  514.                 case 'D':       /* download limit */
    515. 

  515. 		    if( data_limit_raw_out > 0 ) {
    516. 

  516. 			sprintf(outptr,"%" L_FORMAT, TRUNC_KB(data_limit_raw_out));
    517. 

  517. 		    }
    518. 

  518. 		    else if( data_limit_data_out > 0 ) {
    519. 

  519. 			sprintf(outptr,"%" L_FORMAT, TRUNC_KB(data_limit_data_out));
    520. 

  520. 		    }
    521. 

  521. 		    else if( data_limit_raw_total > 0 ) {
    522. 

  522. 			sprintf(outptr,"%" L_FORMAT, TRUNC_KB(data_limit_raw_total));
    523. 

  523. 		    }
    524. 

  524. 		    else if( data_limit_data_total > 0 ) {
    525. 

  525. 			sprintf(outptr,"%" L_FORMAT, TRUNC_KB(data_limit_data_total));
    526. 

  526. 		    }
    527. 

  527. 		    else {
    528. 

  528. 			strcpy(outptr, "unlimited");
    529. 

  529. 		    }
    530. 

  530.                     break;
    531. 

  531.                 default:
    532. 

  532.                     strcpy(outptr,"%??");
    533. 

  533.                     break;
    534. 

  534.                 }
    535. 

  535.                 break;
    536. 

  536. #endif /* RATIO */
    537. 

  537. #endif
    538. 

  538. #endif
    539. 

  539. 		/* File transfer logging (xferlog) */
    540. 

  540. 		case 'X':
    541. 

  541. 		    if (xferdone) {  /* only if a transfer has just occurred */
    542. 

  542. 			switch (*++inptr) {
    543. 

  543. 			case 't':
    544. 

  544. 			    snprintf(outptr, outlen, "%d", xfervalues.transfer_time);
    545. 

  545. 			    break;
    546. 

  546. 			case 's':
    547. 

  547. 			    snprintf(outptr, outlen, "%" L_FORMAT, xfervalues.filesize);
    548. 

  548. 			    break;
    549. 

  549. 			case 'n':
    550. 

  550. 			    snprintf(outptr, outlen, "%" L_FORMAT, xfervalues.transfer_bytes);
    551. 

  551. 			    break;
    552. 

  552. 			case 'P': /* absolute pathname */
    553. 

  553. 			    /* FALLTHROUGH */
    554. 

  554. 			case 'p': /* chroot-relative pathname */
    555. 

  555. 			{
    556. 

  556. 			    char namebuf[MAXPATHLEN];
    557. 

  557. 			    int loop;
    558. 

  558. 

  559. 			    if (*inptr == 'P')
    560. 

  560. 				wu_realpath(xfervalues.filename, namebuf, chroot_path);
    561. 

  561. 			    else
    562. 

  562. 				fb_realpath(xfervalues.filename, namebuf);
    563. 

  563. 			    for (loop = 0; namebuf[loop]; loop++) {
    564. 

  564. 				if (isspace(namebuf[loop]) || iscntrl(namebuf[loop]))
    565. 

  565. 				    namebuf[loop] = '_';
    566. 

  566. 			    }
    567. 

  567. 			    snprintf(outptr, outlen, "%s", namebuf);
    568. 

  568. 			    break;
    569. 

  569. 			}
    570. 

  570. 			case 'y':
    571. 

  571. 			    snprintf(outptr, outlen, "%c", xfervalues.transfer_type);
    572. 

  572. 			    break;
    573. 

  573. 			case 'f':
    574. 

  574. 			    snprintf(outptr, outlen, "%s", xfervalues.special_action);
    575. 

  575. 			    break;
    576. 

  576. 			case 'd':
    577. 

  577. 			    snprintf(outptr, outlen, "%c", xfervalues.transfer_direction);
    578. 

  578. 			    break;
    579. 

  579. 			case 'm':
    580. 

  580. 			    snprintf(outptr, outlen, "%c", xfervalues.access_mode);
    581. 

  581. 			    break;
    582. 

  582. 			case 'a':
    583. 

  583. 			    snprintf(outptr, outlen, "%d", xfervalues.auth);
    584. 

  584. 			    break;
    585. 

  585. 			case 'r':
    586. 

  586. 			    snprintf(outptr, outlen, "%" L_FORMAT, xfervalues.restart_offset);
    587. 

  587. 			    break;
    588. 

  588. 			case 'c':
    589. 

  589. 			    snprintf(outptr, outlen, "%c", xfervalues.completion);
    590. 

  590. 			    break;
    591. 

  591. 			default:
    592. 

  592. 			    snprintf(outptr, outlen, "%%X%c", *inptr);
    593. 

  593. 			    break;
    594. 

  594. 			}
    595. 

  595. 		    }
    596. 

  596. 		    else
    597. 

  597. 			snprintf(outptr, outlen, "%%%c", *inptr);
    598. 

  598. 		    break;
    599. 

  599. 

  600. 	    default:
    601. 

  601. 		*outptr++ = '%';
    602. 

  602. 		outlen -= 1;
    603. 

  603. 		if (outlen > 1) {
    604. 

  604. 		    *outptr++ = *inptr;
    605. 

  605. 		    outlen -= 1;
    606. 

  606. 		}
    607. 

  607. 		*outptr = '\0';
    608. 

  608. 		break;
    609. 

  609. 	    }
    610. 

  610. 	    outptr[outlen - 1] = '\0';
    611. 

  611. 	    while (*outptr) {
    612. 

  612. 		outptr++;
    613. 

  613. 		outlen -= 1;
    614. 

  614. 	    }
    615. 

  615. 	}
    616. 

  616. 	inptr++;
    617. 

  617.     }
    618. 

  618.     if (outlen > 0)
    619. 

  619. 	*outptr = '\0';
    620. 

  620. }
    621. 

  621. 

  622. /*************************************************************************/
    623. 

  623. /* FUNCTION  : cwd_beenhere                                              */
    624. 

  624. /* PURPOSE   : Return 1 if the user has already visited this directory   */
    625. 

  625. /*             via C_WD.                                                 */
    626. 

  626. /* ARGUMENTS : a power-of-two directory function code (README, MESSAGE)  */
    627. 

  627. /*************************************************************************/
    628. 

  628. 

  629. int cwd_beenhere(int dircode)
    630. 

  630. {
    631. 

  631.     struct dirlist {
    632. 

  632. 	struct dirlist *next;
    633. 

  633. 	int dircode;
    634. 

  634. 	char dirname[1];
    635. 

  635.     };
    636. 

  636. 

  637.     static struct dirlist *head = NULL;
    638. 

  638.     struct dirlist *curptr;
    639. 

  639.     char cwd[MAXPATHLEN];
    640. 

  640. 

  641.     (void) fb_realpath(".", cwd);
    642. 

  642. 

  643.     for (curptr = head; curptr != NULL; curptr = curptr->next)
    644. 

  644. 	if (strcmp(curptr->dirname, cwd) == 0) {
    645. 

  645. 	    if (!(curptr->dircode & dircode)) {
    646. 

  646. 		curptr->dircode |= dircode;
    647. 

  647. 		return (0);
    648. 

  648. 	    }
    649. 

  649. 	    return (1);
    650. 

  650. 	}
    651. 

  651.     curptr = (struct dirlist *) malloc(strlen(cwd) + 1 + sizeof(struct dirlist));
    652. 

  652. 

  653.     if (curptr != NULL) {
    654. 

  654. 	curptr->next = head;
    655. 

  655. 	head = curptr;
    656. 

  656. 	curptr->dircode = dircode;
    657. 

  657. 	strcpy(curptr->dirname, cwd);
    658. 

  658.     }
    659. 

  659.     return (0);
    660. 

  660. }
    661. 

  661. 

  662. /*************************************************************************/
    663. 

  663. /* FUNCTION  : show_banner                                               */
    664. 

  664. /* PURPOSE   : Display a banner on the user's terminal before login      */
    665. 

  665. /* ARGUMENTS : reply code to use                                         */
    666. 

  666. /*************************************************************************/
    667. 

  667. 

  668. void show_banner(int msgcode)
    669. 

  669. {
    670. 

  670.     char *crptr, linebuf[1024], outbuf[1024];
    671. 

  671.     struct aclmember *entry = NULL;
    672. 

  672.     FILE *infile;
    673. 

  673. 

  674. #ifdef VIRTUAL
    675. 

  675.     extern int virtual_mode;
    676. 

  676.     extern int virtual_ftpaccess;
    677. 

  677.     extern char virtual_banner[];
    678. 

  678. 

  679.     if (virtual_mode && !virtual_ftpaccess) {
    680. 

  680. 	infile = fopen(virtual_banner, "r");
    681. 

  681. 	if (infile) {
    682. 

  682. 	    while (fgets(linebuf, sizeof(linebuf), infile) != NULL) {
    683. 

  683. 		if ((crptr = strchr(linebuf, '\n')) != NULL)
    684. 

  684. 		    *crptr = '\0';
    685. 

  685. 		msg_massage(linebuf, outbuf, sizeof(outbuf));
    686. 

  686. 		lreply(msgcode, "%s", outbuf);
    687. 

  687. 	    }
    688. 

  688. 	    fclose(infile);
    689. 

  689. #ifndef NO_SUCKING_NEWLINES
    690. 

  690. 	    lreply(msgcode, "");
    691. 

  691. #endif
    692. 

  692. 	}
    693. 

  693.     }
    694. 

  694.     else {
    695. 

  695. #endif
    696. 

  696. 	/* banner <path> */
    697. 

  697. 	while (getaclentry("banner", &entry)) {
    698. 

  698. 	    if (!ARG0)
    699. 

  699. 		continue;
    700. 

  700. 	    infile = fopen(ARG0, "r");
    701. 

  701. 	    if (infile) {
    702. 

  702. 		while (fgets(linebuf, sizeof(linebuf), infile) != NULL) {
    703. 

  703. 		    if ((crptr = strchr(linebuf, '\n')) != NULL)
    704. 

  704. 			*crptr = '\0';
    705. 

  705. 		    msg_massage(linebuf, outbuf, sizeof(outbuf));
    706. 

  706. 		    lreply(msgcode, "%s", outbuf);
    707. 

  707. 		}
    708. 

  708. 		fclose(infile);
    709. 

  709. #ifndef NO_SUCKING_NEWLINES
    710. 

  710. 		lreply(msgcode, "");
    711. 

  711. #endif
    712. 

  712. 	    }
    713. 

  713. 	}
    714. 

  714. #ifdef VIRTUAL
    715. 

  715.     }
    716. 

  716. #endif
    717. 

  717. }
    718. 

  718. /*************************************************************************/
    719. 

  719. /* FUNCTION  : show_message                                              */
    720. 

  720. /* PURPOSE   : Display a message on the user's terminal if the current   */
    721. 

  721. /*             conditions are right                                      */
    722. 

  722. /* ARGUMENTS : reply code to use, LOG_IN|CMD                             */
    723. 

  723. /*************************************************************************/
    724. 

  724. 

  725. void show_message(int msgcode, int mode)
    726. 

  726. {
    727. 

  727.     char *crptr, linebuf[1024], outbuf[1024], class[MAXPATHLEN], cwd[MAXPATHLEN];
    728. 

  728.     int show, which;
    729. 

  729.     struct aclmember *entry = NULL;
    730. 

  730.     FILE *infile;
    731. 

  731. 

  732.     if (mode == C_WD && cwd_beenhere(1) != 0)
    733. 

  733. 	return;
    734. 

  734. 

  735. #ifdef HAVE_GETCWD
    736. 

  736.     (void) getcwd(cwd, MAXPATHLEN - 1);
    737. 

  737. #else
    738. 

  738.     (void) getwd(cwd);
    739. 

  739. #endif
    740. 

  740.     (void) acl_getclass(class);
    741. 

  741. 

  742.     /* message <path> [<when> [<class>]] */
    743. 

  743.     while (getaclentry("message", &entry)) {
    744. 

  744. 	if (!ARG0)
    745. 

  745. 	    continue;
    746. 

  746. 	show = 0;
    747. 

  747. 

  748. 	if (mode == LOG_IN && (!ARG1 || !strcasecmp(ARG1, "login")))
    749. 

  749. 	    if (!ARG2)
    750. 

  750. 		show++;
    751. 

  751. 	    else {
    752. 

  752. 		for (which = 2; (which < MAXARGS) && ARG[which]; which++)
    753. 

  753. 		    if (strcasecmp(class, ARG[which]) == 0)
    754. 

  754. 			show++;
    755. 

  755. 	    }
    756. 

  756. 	if (mode == C_WD && ARG1 && !strncasecmp(ARG1, "cwd=", 4) &&
    757. 

  757. 	    (!strcmp((ARG1) + 4, cwd) || *(ARG1 + 4) == '*' ||
    758. 

  758. 	     !wu_fnmatch((ARG1) + 4, cwd, FNM_PATHNAME)))
    759. 

  759. 	    if (!ARG2)
    760. 

  760. 		show++;
    761. 

  761. 	    else {
    762. 

  762. 		for (which = 2; (which < MAXARGS) && ARG[which]; which++)
    763. 

  763. 		    if (strcasecmp(class, ARG[which]) == 0)
    764. 

  764. 			show++;
    765. 

  765. 	    }
    766. 

  766. 	if (show && (int) strlen(ARG0) > 0) {
    767. 

  767. 	    infile = fopen(ARG0, "r");
    768. 

  768. 	    if (infile) {
    769. 

  769. 		while (fgets(linebuf, sizeof(linebuf), infile) != NULL) {
    770. 

  770. 		    if ((crptr = strchr(linebuf, '\n')) != NULL)
    771. 

  771. 			*crptr = '\0';
    772. 

  772. 		    msg_massage(linebuf, outbuf, sizeof(outbuf));
    773. 

  773. 		    lreply(msgcode, "%s", outbuf);
    774. 

  774. 		}
    775. 

  775. 		fclose(infile);
    776. 

  776. #ifndef NO_SUCKING_NEWLINES
    777. 

  777. 		lreply(msgcode, "");
    778. 

  778. #endif
    779. 

  779. 	    }
    780. 

  780. 	}
    781. 

  781.     }
    782. 

  782. }
    783. 

  783. 

  784. /*************************************************************************/
    785. 

  785. /* FUNCTION  : show_readme                                               */
    786. 

  786. /* PURPOSE   : Display a message about a README file to the user if the  */
    787. 

  787. /*             current conditions are right                              */
    788. 

  788. /* ARGUMENTS : pointer to ACL buffer, reply code, LOG_IN|C_WD            */
    789. 

  789. /*************************************************************************/
    790. 

  790. 

  791. void show_readme(int code, int mode)
    792. 

  792. {
    793. 

  793.     char **filelist, **sfilelist, class[MAXPATHLEN], cwd[MAXPATHLEN];
    794. 

  794.     int show, which, days;
    795. 

  795.     time_t clock;
    796. 

  796. 

  797.     struct stat buf;
    798. 

  798.     struct tm *tp;
    799. 

  799.     struct aclmember *entry = NULL;
    800. 

  800. 

  801.     if (cwd_beenhere(2) != 0)
    802. 

  802. 	return;
    803. 

  803. 

  804. #ifdef HAVE_GETCWD
    805. 

  805.     (void) getcwd(cwd, MAXPATHLEN - 1);
    806. 

  806. #else
    807. 

  807.     (void) getwd(cwd);
    808. 

  808. #endif
    809. 

  809.     (void) acl_getclass(class);
    810. 

  810. 

  811.     /* readme  <path> {<when>} */
    812. 

  812.     while (getaclentry("readme", &entry)) {
    813. 

  813. 	if (!ARG0)
    814. 

  814. 	    continue;
    815. 

  815. 	show = 0;
    816. 

  816. 

  817. 	if (mode == LOG_IN && (!ARG1 || !strcasecmp(ARG1, "login")))
    818. 

  818. 	    if (!ARG2)
    819. 

  819. 		show++;
    820. 

  820. 	    else {
    821. 

  821. 		for (which = 2; (which < MAXARGS) && ARG[which]; which++)
    822. 

  822. 		    if (strcasecmp(class, ARG[which]) == 0)
    823. 

  823. 			show++;
    824. 

  824. 	    }
    825. 

  825. 	if (mode == C_WD && ARG1 && !strncasecmp(ARG1, "cwd=", 4)
    826. 

  826. 	    && (!strcmp((ARG1) + 4, cwd) || *(ARG1 + 4) == '*' ||
    827. 

  827. 		!wu_fnmatch((ARG1) + 4, cwd, FNM_PATHNAME)))
    828. 

  828. 	    if (!ARG2)
    829. 

  829. 		show++;
    830. 

  830. 	    else {
    831. 

  831. 		for (which = 2; (which < MAXARGS) && ARG[which]; which++)
    832. 

  832. 		    if (strcasecmp(class, ARG[which]) == 0)
    833. 

  833. 			show++;
    834. 

  834. 	    }
    835. 

  835. 	if (show) {
    836. 

  836. 	    globerr = NULL;
    837. 

  837. 	    filelist = ftpglob(ARG0, B_TRUE);
    838. 

  838. 	    sfilelist = filelist;	/* save to free later */
    839. 

  839. 	    if (!globerr) {
    840. 

  840. 		while (filelist && *filelist) {
    841. 

  841. 		    errno = 0;
    842. 

  842. 		    if (!stat(*filelist, &buf) &&
    843. 

  843. 			(buf.st_mode & S_IFMT) == S_IFREG) {
    844. 

  844. 			lreply(code, "Please read the file %s", *filelist);
    845. 

  845. 			(void) time(&clock);
    846. 

  846. 			tp = localtime(&clock);
    847. 

  847. 			days = 365 * tp->tm_year + tp->tm_yday;
    848. 

  848. 			tp = localtime((time_t *) & buf.st_mtime);
    849. 

  849. 			days -= 365 * tp->tm_year + tp->tm_yday;
    850. 

  850. /*
    851. 

  851.    if (days == 0) {
    852. 

  852.    lreply(code, "  it was last modified on %.24s - Today",
    853. 

  853.    ctime((time_t *)&buf.st_mtime));
    854. 

  854.    } else {
    855. 

  855.  */
    856. 

  856. 			lreply(code,
    857. 

  857. 			   "  it was last modified on %.24s - %d day%s ago",
    858. 

  858. 			       ctime((time_t *) & buf.st_mtime), days, days == 1 ? "" : "s");
    859. 

  859. /*
    860. 

  860.    }
    861. 

  861.  */
    862. 

  862. 		    }
    863. 

  863. 		    filelist++;
    864. 

  864. 		}
    865. 

  865. 	    }
    866. 

  866. 	    if (sfilelist) {
    867. 

  867. 		blkfree(sfilelist);
    868. 

  868. 		free((char *) sfilelist);
    869. 

  869. 	    }
    870. 

  870. 	}
    871. 

  871.     }
    872. 

  872. }
    873. 

  873. 

  874. /*************************************************************************/
    875. 

  875. /* FUNCTION  : deny_badxfertype                                          */
    876. 

  876. /* PURPOSE   : If user is in ASCII transfer mode and tries to retrieve a */
    877. 

  877. /*             binary file, abort transfer and display appropriate error */
    878. 

  878. /* ARGUMENTS : message code to use for denial, path of file to check for */
    879. 

  879. /*             binary contents or NULL to assume binary file             */
    880. 

  880. /*************************************************************************/
    881. 

  881. 

  882. int deny_badasciixfer(int msgcode, char *filepath)
    883. 

  883. {
    884. 

  884. 

  885.     if (type == TYPE_A && !*filepath) {
    886. 

  886. 	reply(msgcode, "This is a BINARY file, using ASCII mode to transfer will corrupt it.");
    887. 

  887. 	return (1);
    888. 

  888.     }
    889. 

  889.     /* The hooks are here to prevent transfers of actual binary files, not
    890. 

  890.      * just TAR or COMPRESS mode files... */
    891. 

  891.     return (0);
    892. 

  892. }
    893. 

  893. 

  894. /*************************************************************************/
    895. 

  895. /* FUNCTION  : is_shutdown                                               */
    896. 

  896. /* PURPOSE   : Check to see if the server is shutting down, if it is     */
    897. 

  897. /*             arrange for the shutdown message to be sent in the next   */
    898. 

  898. /*             reply to the user                                         */
    899. 

  899. /* ARGUMENTS : whether to arrange for a shutdown message to be sent, new */
    900. 

  900. /*             or existing connection                                    */
    901. 

  901. /* RETURNS   : 1 if shutting down, 0 if not                              */
    902. 

  902. /*************************************************************************/
    903. 

  903. 

  904. int is_shutdown(int quiet, int new)
    905. 

  905. {
    906. 

  906.     static struct tm tmbuf;
    907. 

  907.     static struct stat s_last;
    908. 

  908.     static time_t last = 0, shut, deny, disc;
    909. 

  909.     static int valid;
    910. 

  910.     static char text[2048];
    911. 

  911.     struct stat s_cur;
    912. 

  912. 

  913.     extern char *autospout, Shutdown[];
    914. 

  914. 

  915.     FILE *fp;
    916. 

  916. 

  917.     int deny_off, disc_off;
    918. 

  918. 

  919.     time_t curtime = time(NULL);
    920. 

  920. 

  921.     char buf[1024], linebuf[1024];
    922. 

  922. 

  923.     if (Shutdown[0] == '\0' || stat(Shutdown, &s_cur))
    924. 

  924. 	return (0);
    925. 

  925. 

  926.     if (s_last.st_mtime != s_cur.st_mtime) {
    927. 

  927. 	valid = 0;
    928. 

  928. 

  929. 	fp = fopen(Shutdown, "r");
    930. 

  930. 	if (fp == NULL)
    931. 

  931. 	    return (0);
    932. 

  932. 	s_last = s_cur;
    933. 

  933. 	fgets(buf, sizeof(buf), fp);
    934. 

  934. 	if (sscanf(buf, "%d %d %d %d %d %ld %ld", &tmbuf.tm_year, &tmbuf.tm_mon,
    935. 

  935. 	&tmbuf.tm_mday, &tmbuf.tm_hour, &tmbuf.tm_min, &deny, &disc) != 7) {
    936. 

  936. 	    (void) fclose(fp);
    937. 

  937. 	    return (0);
    938. 

  938. 	}
    939. 

  939. 	valid = 1;
    940. 

  940. 	deny_off = 3600 * (deny / 100) + 60 * (deny % 100);
    941. 

  941. 	disc_off = 3600 * (disc / 100) + 60 * (disc % 100);
    942. 

  942. 

  943. 	tmbuf.tm_year -= 1900;
    944. 

  944. 	tmbuf.tm_isdst = -1;
    945. 

  945. 	shut = mktime(&tmbuf);
    946. 

  946. 	strcpy(shuttime, ctime(&shut));
    947. 

  947. 

  948. 	disc = shut - disc_off;
    949. 

  949. 	strcpy(disctime, ctime(&disc));
    950. 

  950. 

  951. 	deny = shut - deny_off;
    952. 

  952. 	strcpy(denytime, ctime(&deny));
    953. 

  953. 

  954. 	text[0] = '\0';
    955. 

  955. 

  956. 	while (fgets(buf, sizeof(buf), fp) != NULL) {
    957. 

  957. 	    msg_massage(buf, linebuf, sizeof(linebuf));
    958. 

  958. 	    if ((strlen(text) + strlen(linebuf)) < sizeof(text))
    959. 

  959. 		strcat(text, linebuf);
    960. 

  960. 	}
    961. 

  961. 

  962. 	(void) fclose(fp);
    963. 

  963.     }
    964. 

  964.     if (!valid)
    965. 

  965. 	return (0);
    966. 

  966. 

  967.     /* if last == 0, then is_shutdown() only called with quiet == 1 so far */
    968. 

  968.     if (last == 0 && !quiet) {
    969. 

  969. 	autospout = text;	/* warn them for the first time */
    970. 

  970. 	autospout_free = 0;
    971. 

  971. 	last = curtime;
    972. 

  972.     }
    973. 

  973.     /* if a new connection and past deny time, tell caller to drop 'em */
    974. 

  974.     if (new && curtime > deny)
    975. 

  975. 	return (1);
    976. 

  976. 

  977.     /* if past disconnect time, tell caller to drop 'em */
    978. 

  978.     if (curtime > disc)
    979. 

  979. 	return (1);
    980. 

  980. 

  981.     /* if less than 60 seconds to disconnection, warn 'em continuously */
    982. 

  982.     if (curtime > (disc - 60) && !quiet) {
    983. 

  983. 	autospout = text;
    984. 

  984. 	autospout_free = 0;
    985. 

  985. 	last = curtime;
    986. 

  986.     }
    987. 

  987.     /* if less than 15 minutes to disconnection, warn 'em every 5 mins */
    988. 

  988.     if (curtime > (disc - 60 * 15)) {
    989. 

  989. 	if ((curtime - last) > (60 * 5) && !quiet) {
    990. 

  990. 	    autospout = text;
    991. 

  991. 	    autospout_free = 0;
    992. 

  992. 	    last = curtime;
    993. 

  993. 	}
    994. 

  994.     }
    995. 

  995.     /* if less than 24 hours to disconnection, warn 'em every 30 mins */
    996. 

  996.     if (curtime < (disc - 24 * 60 * 60) && !quiet) {
    997. 

  997. 	if ((curtime - last) > (60 * 30)) {
    998. 

  998. 	    autospout = text;
    999. 

  999. 	    autospout_free = 0;
    1000. 

  1000. 	    last = curtime;
    1001. 

  1001. 	}
    1002. 

  1002.     }
    1003. 

  1003.     /* if more than 24 hours to disconnection, warn 'em every 60 mins */
    1004. 

  1004.     if (curtime > (disc - 24 * 60 * 60) && !quiet) {
    1005. 

  1005. 	if ((curtime - last) >= (24 * 60 * 60)) {
    1006. 

  1006. 	    autospout = text;
    1007. 

  1007. 	    autospout_free = 0;
    1008. 

  1008. 	    last = curtime;
    1009. 

  1009. 	}
    1010. 

  1010.     }
    1011. 

  1011.     return (0);
    1012. 

  1012. }
    1013. 

  1013. 

  1014. #ifdef SITE_NEWER
    1015. 

  1015. void newer(char *date, char *path, int showlots)
    1016. 

  1016. {
    1017. 

  1017.     struct tm tm;
    1018. 

  1018. 

  1019.     if (sscanf(date, "%04d%02d%02d%02d%02d%02d",
    1020. 

  1020. 	       &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
    1021. 

  1021. 	       &tm.tm_hour, &tm.tm_min, &tm.tm_sec) == 6) {
    1022. 

  1022. 

  1023. 	tm.tm_year -= 1900;
    1024. 

  1024. 	tm.tm_mon--;
    1025. 

  1025. 	tm.tm_isdst = -1;
    1026. 

  1026. 	newer_time = mktime(&tm);
    1027. 

  1027. 	dout = dataconn("file list", (off_t) - 1, "w");
    1028. 

  1028. 

  1029. 	if (dout != NULL) {
    1030. 

  1030. 	    /* As ftw allocates storage it needs a chance to cleanup, setting
    1031. 

  1031. 	     * ftwflag prevents myoob from calling longjmp, incrementing
    1032. 

  1032. 	     * ftwflag instead which causes check_newer to return non-zero
    1033. 

  1033. 	     * which makes ftw return. */
    1034. 

  1034. 	    ftwflag = 1;
    1035. 

  1035. 	    transflag++;
    1036. 

  1036. 	    show_fullinfo = showlots;
    1037. 

  1037. #if defined(HAVE_FTW)
    1038. 

  1038. 	    ftw(path, check_newer, -1);
    1039. 

  1039. #else
    1040. 

  1040. 	    treewalk(path, check_newer, -1, NULL);
    1041. 

  1041. #endif
    1042. 

  1042. 

  1043. 	    /* don't send a reply if myoob has already replied */
    1044. 

  1044. 	    if (ftwflag == 1) {
    1045. 

  1045. 		if (ferror(dout) != 0)
    1046. 

  1046. 		    perror_reply(550, "Data connection");
    1047. 

  1047. 		else
    1048. 

  1048. 		    reply(226, "Transfer complete.");
    1049. 

  1049. 	    }
    1050. 

  1050. 

  1051. 	    (void) fclose(dout);
    1052. 

  1052. 	    data = -1;
    1053. 

  1053. 	    pdata = -1;
    1054. 

  1054. 	    transflag = 0;
    1055. 

  1055. 	    ftwflag = 0;
    1056. 

  1056. 	}
    1057. 

  1057.     }
    1058. 

  1058.     else
    1059. 

  1059. 	reply(501, "Bad DATE format");
    1060. 

  1060. }
    1061. 

  1061. #endif
    1062. 

  1062. 

  1063. int type_match(char *typelist)
    1064. 

  1064. {
    1065. 

  1065.     char *start, *p;
    1066. 

  1066.     int len;
    1067. 

  1067. 

  1068.     if (typelist == NULL)
    1069. 

  1069. 	return (0);
    1070. 

  1070. 

  1071.     for (p = start = typelist; *start != '\0'; start = p) {
    1072. 

  1072. 	while (*p != '\0' && *p != ',')
    1073. 

  1073. 	    p++;
    1074. 

  1074. 	len = p - start;
    1075. 

  1075. 	if (*p != '\0')
    1076. 

  1076. 	    p++;
    1077. 

  1077. 	if (len == 9 && anonymous && strncasecmp(start, "anonymous", 9) == 0)
    1078. 

  1078. 	    return (1);
    1079. 

  1079. 	if (len == 5 && guest && strncasecmp(start, "guest", 5) == 0)
    1080. 

  1080. 	    return (1);
    1081. 

  1081. 	if (len == 4 && !guest && !anonymous &&
    1082. 

  1082. 	    strncasecmp(start, "real", 4) == 0)
    1083. 

  1083. 	    return (1);
    1084. 

  1084. 

  1085. 	if (len > 6 && strncasecmp(start, "class=", 6) == 0) {
    1086. 

  1086. 	    char class[1024];
    1087. 

  1087. 

  1088. 	    if ((acl_getclass(class) == 1) && (strlen(class) == len - 6) &&
    1089. 

  1089. 		(strncasecmp(start + 6, class, len - 6) == 0))
    1090. 

  1090. 		return (1);
    1091. 

  1091. 	}
    1092. 

  1092.     }
    1093. 

  1093.     return (0);
    1094. 

  1094. }
    1095. 

  1095. 

  1096. int path_compare(char *p1, char *p2)
    1097. 

  1097. {
    1098. 

  1098.     if ((strcmp(p1, "*") == 0) || (wu_fnmatch(p1, p2, FNM_PATHNAME) == 0))	/* 0 means they matched */
    1099. 

  1099. 	return (strlen(p1));
    1100. 

  1100.     else
    1101. 

  1101. 	return (-2);
    1102. 

  1102. }
    1103. 

  1103. 

  1104. void expand_id(void)
    1105. 

  1105. {
    1106. 

  1106.     char class[1024];
    1107. 

  1107.     struct aclmember *entry = NULL;
    1108. 

  1108.     (void) acl_getclass(class);
    1109. 

  1109.     while (getaclentry("upload", &entry)) {
    1110. 

  1110. 	char *q;
    1111. 

  1111. 	int i = 0;
    1112. 

  1112. 	int options = 1;
    1113. 

  1113. 	int classfound = 0;
    1114. 

  1114. 	int classmatched = 0;
    1115. 

  1115. 	while (options
    1116. 

  1116. 	       && (i < MAXARGS)
    1117. 

  1117. 	       && ((q = entry->arg[i]) != (char *) NULL)
    1118. 

  1118. 	       && (q[0] != '\0')) {
    1119. 

  1119. 	    if (strcasecmp(q, "absolute") == 0)
    1120. 

  1120. 		i++;
    1121. 

  1121. 	    else if (strcasecmp(q, "relative") == 0)
    1122. 

  1122. 		i++;
    1123. 

  1123. 	    else if (strncasecmp(q, "class=", 6) == 0) {
    1124. 

  1124. 		i++;
    1125. 

  1125. 		classfound = 1;
    1126. 

  1126. 		if (strcasecmp(q + 6, class) == 0)
    1127. 

  1127. 		    classmatched = 1;
    1128. 

  1128. 	    }
    1129. 

  1129. 	    else if (strcmp(q, "-") == 0) {
    1130. 

  1130. 		i++;
    1131. 

  1131. 		options = 0;
    1132. 

  1132. 	    }
    1133. 

  1133. 	    else
    1134. 

  1134. 		options = 0;
    1135. 

  1135. 	}
    1136. 

  1136. 	if (!classfound || classmatched) {
    1137. 

  1137. 	    char buf[BUFSIZ];
    1138. 

  1138. 	    /*
    1139. 

  1139. 	       *  UID
    1140. 

  1140. 	     */
    1141. 

  1141. 	    if (((i + 3) < MAXARGS)
    1142. 

  1142. 		&& ((q = entry->arg[i + 3]) != (char *) NULL)
    1143. 

  1143. 		&& (q[0] != '\0')
    1144. 

  1144. 		&& (strcmp(q, "*") != 0)) {
    1145. 

  1145. 		if (q[0] == '%')
    1146. 

  1146. 		    sprintf(buf, "%s", q + 1);
    1147. 

  1147. 		else {
    1148. 

  1148. 		    struct passwd *pwent = getpwnam(q);
    1149. 

  1149. 		    if (pwent)
    1150. 

  1150. 			sprintf(buf, "%" PW_UID_FORMAT, pwent->pw_uid);
    1151. 

  1151. 		    else
    1152. 

  1152. 			sprintf(buf, "%d", 0);
    1153. 

  1153. 		}
    1154. 

  1154. 		entry->arg[i + 3] = (char *) malloc(strlen(buf) + 1);
    1155. 

  1155. 		if (entry->arg[i + 3] == NULL) {
    1156. 

  1156. 		    syslog(LOG_ERR, "calloc error in expand_id");
    1157. 

  1157. 		    dologout(1);
    1158. 

  1158. 		}
    1159. 

  1159. 		strcpy(entry->arg[i + 3], buf);
    1160. 

  1160. 	    }
    1161. 

  1161. 	    /*
    1162. 

  1162. 	       *  GID
    1163. 

  1163. 	     */
    1164. 

  1164. 	    if (((i + 4) < MAXARGS)
    1165. 

  1165. 		&& ((q = entry->arg[i + 4]) != (char *) NULL)
    1166. 

  1166. 		&& (q[0] != '\0')
    1167. 

  1167. 		&& (strcmp(q, "*") != 0)) {
    1168. 

  1168. 		if (q[0] == '%')
    1169. 

  1169. 		    sprintf(buf, "%s", q + 1);
    1170. 

  1170. 		else {
    1171. 

  1171. 		    struct group *grent = getgrnam(q);
    1172. 

  1172. 		    if (grent)
    1173. 

  1173. 			sprintf(buf, "%" GR_GID_FORMAT, grent->gr_gid);
    1174. 

  1174. 		    else
    1175. 

  1175. 			sprintf(buf, "%d", 0);
    1176. 

  1176. 		    endgrent();
    1177. 

  1177. 		}
    1178. 

  1178. 		entry->arg[i + 4] = (char *) malloc(strlen(buf) + 1);
    1179. 

  1179. 		if (entry->arg[i + 4] == NULL) {
    1180. 

  1180. 		    syslog(LOG_ERR, "calloc error in expand_id");
    1181. 

  1181. 		    dologout(1);
    1182. 

  1182. 		}
    1183. 

  1183. 		strcpy(entry->arg[i + 4], buf);
    1184. 

  1184. 	    }
    1185. 

  1185. 	}
    1186. 

  1186.     }
    1187. 

  1187. }
    1188. 

  1188. 

  1189. int fn_check(char *name)
    1190. 

  1190. {
    1191. 

  1191.     /* check to see if this is a valid file name... path-filter <type>
    1192. 

  1192.      * <message_file> <allowed_charset> <disallowed> */
    1193. 

  1193. 

  1194.     struct aclmember *entry = NULL;
    1195. 

  1195.     int j;
    1196. 

  1196.     char *path;
    1197. 

  1197. #if ! defined(HAVE_REGEXEC)
    1198. 

  1198.     char *sp;
    1199. 

  1199. #endif
    1200. 

  1200. 

  1201. #ifdef M_UNIX
    1202. 

  1202. #ifdef HAVE_REGEX
    1203. 

  1203.     char *regp;
    1204. 

  1204. #endif
    1205. 

  1205. #endif
    1206. 

  1206. 

  1207. #ifdef HAVE_REGEXEC
    1208. 

  1208.     regex_t regexbuf;
    1209. 

  1209.     regmatch_t regmatchbuf;
    1210. 

  1210.     int rval;
    1211. 

  1211. #endif
    1212. 

  1212. 

  1213. #ifdef LINUX
    1214. 

  1214.     re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
    1215. 

  1215. #endif
    1216. 

  1216. 

  1217.     while (getaclentry("path-filter", &entry) && ARG0 != NULL) {
    1218. 

  1218. 	if (type_match(ARG0) && ARG1 && ARG2) {
    1219. 

  1219. 

  1220. 	    /*
    1221. 

  1221. 	     * check *only* the basename
    1222. 

  1222. 	     */
    1223. 

  1223. 

  1224. 	    if ((path = strrchr(name, '/')))
    1225. 

  1225. 		++path;
    1226. 

  1226. 	    else
    1227. 

  1227. 		path = name;
    1228. 

  1228. 

  1229. 	    /* is it in the allowed character set? */
    1230. 

  1230. #if defined(HAVE_REGEXEC)
    1231. 

  1231. 	    if (regcomp(&regexbuf, ARG2, REG_EXTENDED) != 0) {
    1232. 

  1232. 		reply(550, "HAVE_REGEX error");
    1233. 

  1233. #elif defined(HAVE_REGEX)
    1234. 

  1234. 		if ((sp = regcmp(ARG2, (char *) 0)) == NULL) {
    1235. 

  1235. 		    reply(550, "HAVE_REGEX error");
    1236. 

  1236. #else
    1237. 

  1237. 	    if ((sp = re_comp(ARG2)) != 0) {
    1238. 

  1238. 		perror_reply(550, sp);
    1239. 

  1239. #endif
    1240. 

  1240. 		return (0);
    1241. 

  1241. 	    }
    1242. 

  1242. #if defined(HAVE_REGEXEC)
    1243. 

  1243. 	    rval = regexec(&regexbuf, path, 1, &regmatchbuf, 0);
    1244. 

  1244. 	    regfree(&regexbuf);
    1245. 

  1245. 	    if (rval != 0) {
    1246. 

  1246. #elif defined(HAVE_REGEX)
    1247. 

  1247. #ifdef M_UNIX
    1248. 

  1248. 		regp = regex(sp, path);
    1249. 

  1249. 		free(sp);
    1250. 

  1250. 		if (regp == NULL) {
    1251. 

  1251. #else
    1252. 

  1252. 		if ((regex(sp, path)) == NULL) {
    1253. 

  1253. #endif
    1254. 

  1254. #else
    1255. 

  1255. 	    if ((re_exec(path)) != 1) {
    1256. 

  1256. #endif
    1257. 

  1257. 		pr_mesg(550, ARG1);
    1258. 

  1258. 		reply(550, "%s: Permission denied on server. (Filename (accept))", name);
    1259. 

  1259. 		return (0);
    1260. 

  1260. 	    }
    1261. 

  1261. 	    /* is it in any of the disallowed regexps */
    1262. 

  1262. 

  1263. 	    for (j = 3; j < MAXARGS; ++j) {
    1264. 

  1264. 		/* ARGj == entry->arg[j] */
    1265. 

  1265. 		if (entry->arg[j]) {
    1266. 

  1266. #if defined(HAVE_REGEXEC)
    1267. 

  1267. 		    if (regcomp(&regexbuf, entry->arg[j], REG_EXTENDED) != 0) {
    1268. 

  1268. 			reply(550, "HAVE_REGEX error");
    1269. 

  1269. #elif defined(HAVE_REGEX)
    1270. 

  1270. 			if ((sp = regcmp(entry->arg[j], (char *) 0)) == NULL) {
    1271. 

  1271. 			    reply(550, "HAVE_REGEX error");
    1272. 

  1272. #else
    1273. 

  1273. 		    if ((sp = re_comp(entry->arg[j])) != 0) {
    1274. 

  1274. 			perror_reply(550, sp);
    1275. 

  1275. #endif
    1276. 

  1276. 			return (0);
    1277. 

  1277. 		    }
    1278. 

  1278. #if defined(HAVE_REGEXEC)
    1279. 

  1279. 		    rval = regexec(&regexbuf, path, 1, &regmatchbuf, 0);
    1280. 

  1280. 		    regfree(&regexbuf);
    1281. 

  1281. 		    if (rval == 0) {
    1282. 

  1282. #elif defined(HAVE_REGEX)
    1283. 

  1283. #ifdef M_UNIX
    1284. 

  1284. 			regp = regex(sp, path);
    1285. 

  1285. 			free(sp);
    1286. 

  1286. 			if (regp != NULL) {
    1287. 

  1287. #else
    1288. 

  1288. 			if ((regex(sp, path)) != NULL) {
    1289. 

  1289. #endif
    1290. 

  1290. #else
    1291. 

  1291. 		    if ((re_exec(path)) == 1) {
    1292. 

  1292. #endif
    1293. 

  1293. 			pr_mesg(550, ARG1);
    1294. 

  1294. 			reply(550, "%s: Permission denied on server. (Filename (deny))", name);
    1295. 

  1295. 			return (0);
    1296. 

  1296. 		    }
    1297. 

  1297. 		}
    1298. 

  1298. 	    }
    1299. 

  1299. 	}
    1300. 

  1300.     }
    1301. 

  1301.     return (1);
    1302. 

  1302. }
    1303. 

  1303. 

  1304. int dir_check(char *name, uid_t * uid, gid_t * gid, int *d_mode, int *valid)
    1305. 

  1305. {
    1306. 

  1306.     struct aclmember *entry = NULL;
    1307. 

  1307.     int match_value = -1;
    1308. 

  1308.     char *ap2 = NULL;
    1309. 

  1309.     char *ap3 = NULL;
    1310. 

  1310.     char *ap4 = NULL;
    1311. 

  1311.     char *ap5 = NULL;
    1312. 

  1312.     char *ap6 = NULL;
    1313. 

  1313.     char *ap7 = NULL;
    1314. 

  1314.     char cwdir[MAXPATHLEN];
    1315. 

  1315.     char *pwdir;
    1316. 

  1316.     char abspwdir[MAXPATHLEN];
    1317. 

  1317.     char relpwdir[MAXPATHLEN];
    1318. 

  1318.     char path[MAXPATHLEN];
    1319. 

  1319.     char *sp;
    1320. 

  1320.     struct stat stbuf;
    1321. 

  1321.     int stat_result = -1;
    1322. 

  1322.     char class[1024];
    1323. 

  1323.     extern char *home;
    1324. 

  1324. 

  1325.     (void) acl_getclass(class);
    1326. 

  1326. 

  1327.     *valid = 0;
    1328. 

  1328.     /* what's our current directory? */
    1329. 

  1329. 

  1330.     /* XXX We could use dynamic RAM to store this path, but I'd rather just bail
    1331. 

  1331.        out with an error. The rest of wu is so crufy that a long path might
    1332. 

  1332.        just blow up later */
    1333. 

  1333. 

  1334.     if ((strlen(name) + 1) > sizeof(path)) {
    1335. 

  1335. 	perror_reply(550, "Path too long");
    1336. 

  1336. 	return (-1);
    1337. 

  1337.     }
    1338. 

  1338. 

  1339.     strcpy(path, name);
    1340. 

  1340.     sp = strrchr(path, '/');
    1341. 

  1341.     if (sp)
    1342. 

  1342. 	*sp = '\0';
    1343. 

  1343.     else
    1344. 

  1344. 	strcpy(path, ".");
    1345. 

  1345. 

  1346.     if ((fb_realpath(path, cwdir)) == NULL) {
    1347. 

  1347. 	perror_reply(550, "Could not determine cwdir");
    1348. 

  1348. 	return (-1);
    1349. 

  1349.     }
    1350. 

  1350. 

  1351.     if ((fb_realpath(home, relpwdir)) == NULL) {
    1352. 

  1352. 	perror_reply(550, "Could not determine pwdir");
    1353. 

  1353. 	return (-1);
    1354. 

  1354.     }
    1355. 

  1355. 

  1356.     if ((wu_realpath(home, abspwdir, chroot_path)) == NULL) {
    1357. 

  1357. 	perror_reply(550, "Could not determine pwdir");
    1358. 

  1358. 	return (-1);
    1359. 

  1359.     }
    1360. 

  1360. 

  1361.     while (getaclentry("upload", &entry)) {
    1362. 

  1362. 	char *q;
    1363. 

  1363. 	int i = 0;
    1364. 

  1364. 	int options = 1;
    1365. 

  1365. 	int classfound = 0;
    1366. 

  1366. 	int classmatched = 0;
    1367. 

  1367. 	pwdir = abspwdir;
    1368. 

  1368. 	while (options
    1369. 

  1369. 	       && (i < MAXARGS)
    1370. 

  1370. 	       && ((q = entry->arg[i]) != (char *) NULL)
    1371. 

  1371. 	       && (q[0] != '\0')) {
    1372. 

  1372. 	    if (strcasecmp(q, "absolute") == 0) {
    1373. 

  1373. 		i++;
    1374. 

  1374. 		pwdir = abspwdir;
    1375. 

  1375. 	    }
    1376. 

  1376. 	    else if (strcasecmp(q, "relative") == 0) {
    1377. 

  1377. 		i++;
    1378. 

  1378. 		pwdir = relpwdir;
    1379. 

  1379. 	    }
    1380. 

  1380. 	    else if (strncasecmp(q, "class=", 6) == 0) {
    1381. 

  1381. 		i++;
    1382. 

  1382. 		classfound = 1;
    1383. 

  1383. 		if (strcasecmp(q + 6, class) == 0)
    1384. 

  1384. 		    classmatched = 1;
    1385. 

  1385. 	    }
    1386. 

  1386. 	    else if (strcmp(q, "-") == 0) {
    1387. 

  1387. 		i++;
    1388. 

  1388. 		options = 0;
    1389. 

  1389. 	    }
    1390. 

  1390. 	    else
    1391. 

  1391. 		options = 0;
    1392. 

  1392. 	}
    1393. 

  1393. 	if (!classfound || classmatched) {
    1394. 

  1394. 	    int j;
    1395. 

  1395. 	    if (((i + 1) < MAXARGS)
    1396. 

  1396. 		&& ((q = entry->arg[i]) != (char *) NULL)
    1397. 

  1397. 		&& (q[0] != '\0')
    1398. 

  1398. 		&& (0 < path_compare(q, pwdir))
    1399. 

  1399. 		&& ((j = path_compare(entry->arg[i + 1], cwdir)) >= match_value)) {
    1400. 

  1400. 		match_value = j;
    1401. 

  1401. 

  1402. 		ap2 = NULL;
    1403. 

  1403. 		if (((i + 2) < MAXARGS)
    1404. 

  1404. 		    && ((q = entry->arg[i + 2]) != (char *) NULL)
    1405. 

  1405. 		    && (q[0] != '\0'))
    1406. 

  1406. 		    ap2 = q;
    1407. 

  1407. 

  1408. 		ap3 = NULL;
    1409. 

  1409. 		if (((i + 3) < MAXARGS)
    1410. 

  1410. 		    && ((q = entry->arg[i + 3]) != (char *) NULL)
    1411. 

  1411. 		    && (q[0] != '\0'))
    1412. 

  1412. 		    ap3 = q;
    1413. 

  1413. 

  1414. 		ap4 = NULL;
    1415. 

  1415. 		if (((i + 4) < MAXARGS)
    1416. 

  1416. 		    && ((q = entry->arg[i + 4]) != (char *) NULL)
    1417. 

  1417. 		    && (q[0] != '\0'))
    1418. 

  1418. 		    ap4 = q;
    1419. 

  1419. 

  1420. 		ap5 = NULL;
    1421. 

  1421. 		if (((i + 5) < MAXARGS)
    1422. 

  1422. 		    && ((q = entry->arg[i + 5]) != (char *) NULL)
    1423. 

  1423. 		    && (q[0] != '\0'))
    1424. 

  1424. 		    ap5 = q;
    1425. 

  1425. 

  1426. 		ap6 = NULL;
    1427. 

  1427. 		if (((i + 6) < MAXARGS)
    1428. 

  1428. 		    && ((q = entry->arg[i + 6]) != (char *) NULL)
    1429. 

  1429. 		    && (q[0] != '\0'))
    1430. 

  1430. 		    ap6 = q;
    1431. 

  1431. 

  1432. 		ap7 = NULL;
    1433. 

  1433. 		if (((i + 7) < MAXARGS)
    1434. 

  1434. 		    && ((q = entry->arg[i + 7]) != (char *) NULL)
    1435. 

  1435. 		    && (q[0] != '\0'))
    1436. 

  1436. 		    ap7 = q;
    1437. 

  1437. 	    }
    1438. 

  1438. 	}
    1439. 

  1439.     }
    1440. 

  1440. 

  1441.     if (anonymous && (match_value < 0)) {
    1442. 

  1442. 	reply(550, "%s: Permission denied on server. (Upload dirs)", name);
    1443. 

  1443. 	return (0);
    1444. 

  1444.     }
    1445. 

  1445.     if ((ap2 && !strcasecmp(ap2, "no"))
    1446. 

  1446. 	|| (ap3 && !strcasecmp(ap3, "nodirs"))
    1447. 

  1447. 	|| (ap6 && !strcasecmp(ap6, "nodirs"))) {
    1448. 

  1448. 	reply(550, "%s: Permission denied on server. (Upload dirs)", name);
    1449. 

  1449. 	return (0);
    1450. 

  1450.     }
    1451. 

  1451.     if ((ap3 && *ap3 == '*') || (ap4 && *ap4 == '*'))
    1452. 

  1452. 	stat_result = stat(path, &stbuf);
    1453. 

  1453.     if (ap3) {
    1454. 

  1454. 	if ((ap3[0] != '*') || (ap3[1] != '\0'))
    1455. 

  1455. 	    *uid = atoi(ap3);	/* the uid  */
    1456. 

  1456. 	else if (stat_result == 0)
    1457. 

  1457. 	    *uid = stbuf.st_uid;
    1458. 

  1458.     }
    1459. 

  1459.     if (ap4) {
    1460. 

  1460. 	if ((ap4[0] != '*') || (ap4[1] != '\0'))
    1461. 

  1461. 	    *gid = atoi(ap4);	/* the gid */
    1462. 

  1462. 	else if (stat_result == 0)
    1463. 

  1463. 	    *gid = stbuf.st_gid;
    1464. 

  1464.     }
    1465. 

  1465.     if (ap7) {
    1466. 

  1466. 	sscanf(ap7, "%o", d_mode);
    1467. 

  1467. 	*valid = 1;
    1468. 

  1468.     }
    1469. 

  1469.     else if (ap5) {
    1470. 

  1470. 	sscanf(ap5, "%o", d_mode);
    1471. 

  1471. 	if (*d_mode & 0600)
    1472. 

  1472. 	    *d_mode |= 0100;
    1473. 

  1473. 	if (*d_mode & 0060)
    1474. 

  1474. 	    *d_mode |= 0010;
    1475. 

  1475. 	if (*d_mode & 0006)
    1476. 

  1476. 	    *d_mode |= 0001;
    1477. 

  1477. 	*valid = 1;
    1478. 

  1478.     }
    1479. 

  1479.     return (1);
    1480. 

  1480. }
    1481. 

  1481. 

  1482. int upl_check(char *name, uid_t * uid, gid_t * gid, int *f_mode, int *valid)
    1483. 

  1483. {
    1484. 

  1484.     int match_value = -1;
    1485. 

  1485.     char cwdir[MAXPATHLEN];
    1486. 

  1486.     char *pwdir;
    1487. 

  1487.     char abspwdir[MAXPATHLEN];
    1488. 

  1488.     char relpwdir[MAXPATHLEN];
    1489. 

  1489.     char path[MAXPATHLEN];
    1490. 

  1490.     char *sp;
    1491. 

  1491.     struct stat stbuf;
    1492. 

  1492.     int stat_result = -1;
    1493. 

  1493.     char *ap2 = NULL;
    1494. 

  1494.     char *ap3 = NULL;
    1495. 

  1495.     char *ap4 = NULL;
    1496. 

  1496.     char *ap5 = NULL;
    1497. 

  1497.     struct aclmember *entry = NULL;
    1498. 

  1498.     char class[1024];
    1499. 

  1499.     extern char *home;
    1500. 

  1500. 

  1501.     *valid = 0;
    1502. 

  1502.     (void) acl_getclass(class);
    1503. 

  1503. 

  1504.     /* what's our current directory? */
    1505. 

  1505. 

  1506.     /* XXX We could use dynamic RAM to store this path, but I'd rather just bail
    1507. 

  1507.        out with an error. The rest of wu is so crufy that a long path might
    1508. 

  1508.        just blow up later */
    1509. 

  1509. 

  1510.     if ((strlen(name) + 1) > sizeof(path)) {
    1511. 

  1511. 	perror_reply(553, "Path too long");
    1512. 

  1512. 	return (-1);
    1513. 

  1513.     }
    1514. 

  1514. 

  1515.     strcpy(path, name);
    1516. 

  1516.     sp = strrchr(path, '/');
    1517. 

  1517.     if (sp)
    1518. 

  1518. 	*sp = '\0';
    1519. 

  1519.     else
    1520. 

  1520. 	strcpy(path, ".");
    1521. 

  1521. 

  1522.     if ((fb_realpath(path, cwdir)) == NULL) {
    1523. 

  1523. 	perror_reply(553, "Could not determine cwdir");
    1524. 

  1524. 	return (-1);
    1525. 

  1525.     }
    1526. 

  1526. 

  1527.     if ((wu_realpath(home, abspwdir, chroot_path)) == NULL) {
    1528. 

  1528. 	perror_reply(553, "Could not determine pwdir");
    1529. 

  1529. 	return (-1);
    1530. 

  1530.     }
    1531. 

  1531. 

  1532.     if ((fb_realpath(home, relpwdir)) == NULL) {
    1533. 

  1533. 	perror_reply(553, "Could not determine pwdir");
    1534. 

  1534. 	return (-1);
    1535. 

  1535.     }
    1536. 

  1536. 

  1537.     /*
    1538. 

  1538.        *  we are doing a "best match"... ..so we keep track of what "match
    1539. 

  1539.        *  value" we have received so far...
    1540. 

  1540.      */
    1541. 

  1541.     while (getaclentry("upload", &entry)) {
    1542. 

  1542. 	char *q;
    1543. 

  1543. 	int i = 0;
    1544. 

  1544. 	int options = 1;
    1545. 

  1545. 	int classfound = 0;
    1546. 

  1546. 	int classmatched = 0;
    1547. 

  1547. 	pwdir = abspwdir;
    1548. 

  1548. 	while (options
    1549. 

  1549. 	       && (i < MAXARGS)
    1550. 

  1550. 	       && ((q = entry->arg[i]) != (char *) NULL)
    1551. 

  1551. 	       && (q[0] != '\0')) {
    1552. 

  1552. 	    if (strcasecmp(q, "absolute") == 0) {
    1553. 

  1553. 		i++;
    1554. 

  1554. 		pwdir = abspwdir;
    1555. 

  1555. 	    }
    1556. 

  1556. 	    else if (strcasecmp(q, "relative") == 0) {
    1557. 

  1557. 		i++;
    1558. 

  1558. 		pwdir = relpwdir;
    1559. 

  1559. 	    }
    1560. 

  1560. 	    else if (strncasecmp(q, "class=", 6) == 0) {
    1561. 

  1561. 		i++;
    1562. 

  1562. 		classfound = 1;
    1563. 

  1563. 		if (strcasecmp(q + 6, class) == 0)
    1564. 

  1564. 		    classmatched = 1;
    1565. 

  1565. 	    }
    1566. 

  1566. 	    else if (strcmp(q, "-") == 0) {
    1567. 

  1567. 		i++;
    1568. 

  1568. 		options = 0;
    1569. 

  1569. 	    }
    1570. 

  1570. 	    else
    1571. 

  1571. 		options = 0;
    1572. 

  1572. 	}
    1573. 

  1573. 	if (!classfound || classmatched) {
    1574. 

  1574. 	    int j;
    1575. 

  1575. 	    if (((i + 1) < MAXARGS)
    1576. 

  1576. 		&& ((q = entry->arg[i]) != (char *) NULL)
    1577. 

  1577. 		&& (q[0] != '\0')
    1578. 

  1578. 		&& (0 < path_compare(q, pwdir))
    1579. 

  1579. 		&& ((j = path_compare(entry->arg[i + 1], cwdir)) >= match_value)) {
    1580. 

  1580. 		match_value = j;
    1581. 

  1581. 

  1582. 		ap2 = NULL;
    1583. 

  1583. 		if (((i + 2) < MAXARGS)
    1584. 

  1584. 		    && ((q = entry->arg[i + 2]) != (char *) NULL)
    1585. 

  1585. 		    && (q[0] != '\0'))
    1586. 

  1586. 		    ap2 = q;
    1587. 

  1587. 

  1588. 		ap3 = NULL;
    1589. 

  1589. 		if (((i + 3) < MAXARGS)
    1590. 

  1590. 		    && ((q = entry->arg[i + 3]) != (char *) NULL)
    1591. 

  1591. 		    && (q[0] != '\0'))
    1592. 

  1592. 		    ap3 = q;
    1593. 

  1593. 

  1594. 		ap4 = NULL;
    1595. 

  1595. 		if (((i + 4) < MAXARGS)
    1596. 

  1596. 		    && ((q = entry->arg[i + 4]) != (char *) NULL)
    1597. 

  1597. 		    && (q[0] != '\0'))
    1598. 

  1598. 		    ap4 = q;
    1599. 

  1599. 

  1600. 		ap5 = NULL;
    1601. 

  1601. 		if (((i + 5) < MAXARGS)
    1602. 

  1602. 		    && ((q = entry->arg[i + 5]) != (char *) NULL)
    1603. 

  1603. 		    && (q[0] != '\0'))
    1604. 

  1604. 		    ap5 = q;
    1605. 

  1605. 	    }
    1606. 

  1606. 	}
    1607. 

  1607.     }
    1608. 

  1608. 

  1609.     if (ap3
    1610. 

  1610. 	&& ((!strcasecmp("dirs", ap3))
    1611. 

  1611. 	    || (!strcasecmp("nodirs", ap3))))
    1612. 

  1612. 	ap3 = NULL;
    1613. 

  1613. 

  1614.     /*
    1615. 

  1615.        *  if we did get matches ... else don't do any of this stuff
    1616. 

  1616.      */
    1617. 

  1617.     if (match_value >= 0) {
    1618. 

  1618. 	if (!strcasecmp(ap2, "yes")) {
    1619. 

  1619. 	    if ((ap3 && *ap3 == '*') || (ap4 && *ap4 == '*'))
    1620. 

  1620. 		stat_result = stat(path, &stbuf);
    1621. 

  1621. 	    if (ap3) {
    1622. 

  1622. 		if ((ap3[0] != '*') || (ap3[1] != '\0'))
    1623. 

  1623. 		    *uid = atoi(ap3);	/* the uid  */
    1624. 

  1624. 		else if (stat_result == 0)
    1625. 

  1625. 		    *uid = stbuf.st_uid;
    1626. 

  1626. 	    }
    1627. 

  1627. 	    if (ap4) {
    1628. 

  1628. 		if ((ap4[0] != '*') || (ap4[1] != '\0'))
    1629. 

  1629. 		    *gid = atoi(ap4);	/* the gid  */
    1630. 

  1630. 		else if (stat_result == 0)
    1631. 

  1631. 		    *gid = stbuf.st_gid;
    1632. 

  1632. 		*valid = 1;
    1633. 

  1633. 	    }
    1634. 

  1634. 	    if (ap5)
    1635. 

  1635. 		sscanf(ap5, "%o", f_mode);	/* the mode */
    1636. 

  1636. 	}
    1637. 

  1637. 	else {
    1638. 

  1638. 	    reply(553, "%s: Permission denied on server. (Upload)", name);
    1639. 

  1639. 	    return (-1);
    1640. 

  1640. 	}
    1641. 

  1641.     }
    1642. 

  1642.     else {
    1643. 

  1643. 	/*
    1644. 

  1644. 	   *  upload defaults to "permitted"
    1645. 

  1645. 	 */
    1646. 

  1646. 	/* Not if anonymous */
    1647. 

  1647. 	if (anonymous) {
    1648. 

  1648. 	    reply(553, "%s: Permission denied on server. (Upload)", name);
    1649. 

  1649. 	    return (-1);
    1650. 

  1650. 	}
    1651. 

  1651. 	return (1);
    1652. 

  1652.     }
    1653. 

  1653. 

  1654.     return (match_value);
    1655. 

  1655. }
    1656. 

  1656. 

  1657. int del_check(char *name)
    1658. 

  1658. {
    1659. 

  1659.     int pdelete = (anonymous ? 0 : 1);
    1660. 

  1660.     struct aclmember *entry = NULL;
    1661. 

  1661. 

  1662.     while (getaclentry("delete", &entry) && ARG0 && ARG1 != NULL) {
    1663. 

  1663. 	if (type_match(ARG1))
    1664. 

  1664. 	    if (anonymous) {
    1665. 

  1665. 		if (*ARG0 == 'y')
    1666. 

  1666. 		    pdelete = 1;
    1667. 

  1667. 	    }
    1668. 

  1668. 	    else if (*ARG0 == 'n')
    1669. 

  1669. 		pdelete = 0;
    1670. 

  1670.     }
    1671. 

  1671. 

  1672. /* H* fix: no deletion, period. You put a file here, I get to look at it. */
    1673. 

  1673. #ifdef PARANOID
    1674. 

  1674.     pdelete = 0;
    1675. 

  1675. #endif
    1676. 

  1676. 

  1677.     if (!pdelete) {
    1678. 

  1678. 	reply(553, "%s: Permission denied on server. (Delete)", name);
    1679. 

  1679. 	return (0);
    1680. 

  1680.     }
    1681. 

  1681.     else {
    1682. 

  1682. 	return (1);
    1683. 

  1683.     }
    1684. 

  1684. }
    1685. 

  1685. 

  1686. /* The following is from the Debian add-ons. */
    1687. 

  1687. 

  1688. #define lbasename(x) (strrchr(x,'/')?1+strrchr(x,'/'):x)
    1689. 

  1689. 

  1690. int regexmatch(char *name, char *rgexp)
    1691. 

  1691. {
    1692. 

  1692. 

  1693. #ifdef M_UNIX
    1694. 

  1694. #ifdef HAVE_REGEX
    1695. 

  1695.     char *regp;
    1696. 

  1696. #endif
    1697. 

  1697. #endif
    1698. 

  1698. 

  1699. #ifdef HAVE_REGEXEC
    1700. 

  1700.     regex_t regexbuf;
    1701. 

  1701.     regmatch_t regmatchbuf;
    1702. 

  1702.     int rval;
    1703. 

  1703. #else
    1704. 

  1704.     char *sp;
    1705. 

  1705. #endif
    1706. 

  1706. 

  1707. #if defined(HAVE_REGEXEC)
    1708. 

  1708.     if (regcomp(&regexbuf, rgexp, REG_EXTENDED) != 0) {
    1709. 

  1709. 	reply(553, "HAVE_REGEX error");
    1710. 

  1710. #elif defined(HAVE_REGEX)
    1711. 

  1711. 	if ((sp = regcmp(rgexp, (char *) 0)) == NULL) {
    1712. 

  1712. 	    reply(553, "HAVE_REGEX error");
    1713. 

  1713. #else
    1714. 

  1714.     if ((sp = re_comp(rgexp)) != 0) {
    1715. 

  1715. 	perror_reply(553, sp);
    1716. 

  1716. #endif
    1717. 

  1717. 	return (0);
    1718. 

  1718.     }
    1719. 

  1719. 

  1720. #if defined(HAVE_REGEXEC)
    1721. 

  1721.     rval = regexec(&regexbuf, name, 1, &regmatchbuf, 0);
    1722. 

  1722.     regfree(&regexbuf);
    1723. 

  1723.     if (rval != 0) {
    1724. 

  1724. #elif defined(HAVE_REGEX)
    1725. 

  1725. #ifdef M_UNIX
    1726. 

  1726. 	regp = regex(sp, name);
    1727. 

  1727. 	free(sp);
    1728. 

  1728. 	if (regp == NULL) {
    1729. 

  1729. #else
    1730. 

  1730. 	if ((regex(sp, name)) == NULL) {
    1731. 

  1731. #endif
    1732. 

  1732. #else
    1733. 

  1733.     if ((re_exec(name)) != 1) {
    1734. 

  1734. #endif
    1735. 

  1735. 	return (0);
    1736. 

  1736.     }
    1737. 

  1737.     return (1);
    1738. 

  1738. }
    1739. 

  1739. 

  1740. static int allow_retrieve(char *name)
    1741. 

  1741. {
    1742. 

  1742.     char realname[MAXPATHLEN + 1];
    1743. 

  1743.     char localname[MAXPATHLEN + 1];
    1744. 

  1744.     char *whichname;
    1745. 

  1745.     int i;
    1746. 

  1746.     struct aclmember *entry = NULL;
    1747. 

  1747.     char *p, *q;
    1748. 

  1748.     int options;
    1749. 

  1749.     int classfound;
    1750. 

  1750.     int classmatched;
    1751. 

  1751.     char class[1024];
    1752. 

  1752. 

  1753.     (void) acl_getclass(class);
    1754. 

  1754.     if ((name == (char *) NULL)
    1755. 

  1755. 	|| (*name == '\0'))
    1756. 

  1756. 	return 0;
    1757. 

  1757.     fb_realpath(name, localname);
    1758. 

  1758.     wu_realpath(name, realname, chroot_path);
    1759. 

  1759.     while (getaclentry("allow-retrieve", &entry)) {
    1760. 

  1760. 	whichname = realname;
    1761. 

  1761. 	i = 0;
    1762. 

  1762. 	options = 1;
    1763. 

  1763. 	classfound = 0;
    1764. 

  1764. 	classmatched = 0;
    1765. 

  1765. 	while (options
    1766. 

  1766. 	       && (i < MAXARGS)
    1767. 

  1767. 	       && ((q = entry->arg[i]) != (char *) NULL)
    1768. 

  1768. 	       && (q[0] != '\0')) {
    1769. 

  1769. 	    if (strcasecmp(q, "absolute") == 0) {
    1770. 

  1770. 		i++;
    1771. 

  1771. 		whichname = realname;
    1772. 

  1772. 	    }
    1773. 

  1773. 	    else if (strcasecmp(q, "relative") == 0) {
    1774. 

  1774. 		i++;
    1775. 

  1775. 		whichname = localname;
    1776. 

  1776. 	    }
    1777. 

  1777. 	    else if (strncasecmp(q, "class=", 6) == 0) {
    1778. 

  1778. 		i++;
    1779. 

  1779. 		classfound = 1;
    1780. 

  1780. 		if (strcasecmp(q + 6, class) == 0)
    1781. 

  1781. 		    classmatched = 1;
    1782. 

  1782. 	    }
    1783. 

  1783. 	    else if (strcmp(q, "-") == 0) {
    1784. 

  1784. 		i++;
    1785. 

  1785. 		options = 0;
    1786. 

  1786. 	    }
    1787. 

  1787. 	    else
    1788. 

  1788. 		options = 0;
    1789. 

  1789. 	}
    1790. 

  1790. 	if (!classfound || classmatched) {
    1791. 

  1791. 	    for (; (i < MAXARGS) && ((q = entry->arg[i]) != (char *) NULL) && (q[0] != '\0'); i++) {
    1792. 

  1792. 		p = (q[0] == '/') ? whichname : lbasename(whichname);
    1793. 

  1793. 		if (!wu_fnmatch(q, p, FNM_PATHNAME | FNM_LEADING_DIR)) {
    1794. 

  1794. 		    return 1;
    1795. 

  1795. 		}
    1796. 

  1796. 	    }
    1797. 

  1797. 	}
    1798. 

  1798.     }
    1799. 

  1799.     return 0;
    1800. 

  1800. }
    1801. 

  1801. 

  1802. int checknoretrieve(char *name)
    1803. 

  1803. {
    1804. 

  1804.     char realname[MAXPATHLEN + 1];
    1805. 

  1805.     char localname[MAXPATHLEN + 1];
    1806. 

  1806.     char *whichname;
    1807. 

  1807.     int i;
    1808. 

  1808.     struct aclmember *entry = NULL;
    1809. 

  1809.     char *p, *q;
    1810. 

  1810.     int options;
    1811. 

  1811.     int classfound;
    1812. 

  1812.     int classmatched;
    1813. 

  1813.     char class[1024];
    1814. 

  1814. 

  1815.     extern struct passwd *pw;
    1816. 

  1816.     extern char *remoteident;
    1817. 

  1817. 

  1818.     (void) acl_getclass(class);
    1819. 

  1819.     if ((name == (char *) NULL)
    1820. 

  1820. 	|| (*name == '\0'))
    1821. 

  1821. 	return 0;
    1822. 

  1822.     fb_realpath(name, localname);
    1823. 

  1823.     wu_realpath(name, realname, chroot_path);
    1824. 

  1824.     while (getaclentry("noretrieve", &entry)) {
    1825. 

  1825. 	whichname = realname;
    1826. 

  1826. 	i = 0;
    1827. 

  1827. 	options = 1;
    1828. 

  1828. 	classfound = 0;
    1829. 

  1829. 	classmatched = 0;
    1830. 

  1830. 	while (options
    1831. 

  1831. 	       && (i < MAXARGS)
    1832. 

  1832. 	       && ((q = entry->arg[i]) != (char *) NULL)
    1833. 

  1833. 	       && (q[0] != '\0')) {
    1834. 

  1834. 	    if (strcasecmp(q, "absolute") == 0) {
    1835. 

  1835. 		i++;
    1836. 

  1836. 		whichname = realname;
    1837. 

  1837. 	    }
    1838. 

  1838. 	    else if (strcasecmp(q, "relative") == 0) {
    1839. 

  1839. 		i++;
    1840. 

  1840. 		whichname = localname;
    1841. 

  1841. 	    }
    1842. 

  1842. 	    else if (strncasecmp(q, "class=", 6) == 0) {
    1843. 

  1843. 		i++;
    1844. 

  1844. 		classfound = 1;
    1845. 

  1845. 		if (strcasecmp(q + 6, class) == 0)
    1846. 

  1846. 		    classmatched = 1;
    1847. 

  1847. 	    }
    1848. 

  1848. 	    else if (strcmp(q, "-") == 0) {
    1849. 

  1849. 		i++;
    1850. 

  1850. 		options = 0;
    1851. 

  1851. 	    }
    1852. 

  1852. 	    else
    1853. 

  1853. 		options = 0;
    1854. 

  1854. 	}
    1855. 

  1855. 	if (!classfound || classmatched) {
    1856. 

  1856. 	    for (; (i < MAXARGS) && ((q = entry->arg[i]) != (char *) NULL) && (q[0] != '\0'); i++) {
    1857. 

  1857. 		p = (q[0] == '/') ? whichname : lbasename(whichname);
    1858. 

  1858. 		if (!wu_fnmatch(q, p, FNM_PATHNAME | FNM_LEADING_DIR)) {
    1859. 

  1859. 		    if (!allow_retrieve(name)) {
    1860. 

  1860. 			reply(550, "%s is marked unretrievable", localname);
    1861. 

  1861. 			return 1;
    1862. 

  1862. 		    }
    1863. 

  1863. 		}
    1864. 

  1864. 	    }
    1865. 

  1865. 	}
    1866. 

  1866.     }
    1867. 

  1867.     return 0;
    1868. 

  1868. }
    1869. 

  1869. 

  1870. #ifdef QUOTA
    1871. 

  1871. 

  1872. #ifndef MNTMAXSTR
    1873. 

  1873. #define MNTMAXSTR 2048		/* And hope it's enough */
    1874. 

  1874. #endif
    1875. 

  1875. 

  1876. #ifdef QUOTA_DEVICE
    1877. 

  1877. 

  1878. int path_to_device(char *pathname, char *result)
    1879. 

  1879. {
    1880. 

  1880.     FILE *fp;
    1881. 

  1881. #ifdef HAS_OLDSTYLE_GETMNTENT
    1882. 

  1882.     struct mnttab static_mp;
    1883. 

  1883.     struct mnttab *mp = &static_mp;
    1884. 

  1884. #else
    1885. 

  1885.     struct mntent *mp;
    1886. 

  1886. #endif
    1887. 

  1887.     struct mount_ent {
    1888. 

  1888. 	char mnt_fsname[MNTMAXSTR], mnt_dir[MNTMAXSTR];
    1889. 

  1889. 	struct mount_ent *next;
    1890. 

  1890.     } mountent;
    1891. 

  1891.     struct mount_ent *current, *start, *new;
    1892. 

  1892.     char path[1024], mnt_dir[1024], *pos;
    1893. 

  1893.     int flag = 1;
    1894. 

  1894. 

  1895.     start = current = NULL;
    1896. 

  1896. #ifdef HAS_OLDSTYLE_GETMNTENT
    1897. 

  1897.     fp = fopen(MNTTAB, "r");
    1898. 

  1898. #else
    1899. 

  1899.     fp = setmntent(MNTTAB, "r");
    1900. 

  1900. #endif
    1901. 

  1901.     if (fp == NULL)
    1902. 

  1902. 	return 0;
    1903. 

  1903. #ifdef HAS_OLDSTYLE_GETMNTENT
    1904. 

  1904.     while (getmntent(fp, &static_mp) == 0)
    1905. 

  1905. #else
    1906. 

  1906.     while (mp = getmntent(fp))
    1907. 

  1907. #endif
    1908. 

  1908.     {
    1909. 

  1909. 	if (!(new = (struct mount_ent *) malloc(sizeof(mountent)))) {
    1910. 

  1910. 	    perror("malloc");
    1911. 

  1911. 	    flag = 0;
    1912. 

  1912. 	    break;
    1913. 

  1913. 	}
    1914. 

  1914. 

  1915. 	if (!start)
    1916. 

  1916. 	    start = current = new;
    1917. 

  1917. 	else
    1918. 

  1918. 	    current = current->next = new;
    1919. 

  1919. 

  1920. #ifdef HAS_OLDSTYLE_GETMNTENT
    1921. 

  1921. 	strncpy(current->mnt_fsname, mp->mnt_special, strlen(mp->mnt_special) + 1);
    1922. 

  1922. 	strncpy(current->mnt_dir, mp->mnt_mountp, strlen(mp->mnt_mountp) + 1);
    1923. 

  1923. #else
    1924. 

  1924. 	strncpy(current->mnt_fsname, mp->mnt_fsname, strlen(mp->mnt_fsname) + 1);
    1925. 

  1925. 	strncpy(current->mnt_dir, mp->mnt_dir, strlen(mp->mnt_dir) + 1);
    1926. 

  1926. #endif
    1927. 

  1927.     }
    1928. 

  1928. #ifdef HAS_OLDSTYLE_GETMNTENT
    1929. 

  1929.     fclose(fp);
    1930. 

  1930. #else
    1931. 

  1931.     endmntent(fp);
    1932. 

  1932. #endif
    1933. 

  1933.     current->next = NULL;
    1934. 

  1934. 

  1935.     wu_realpath(pathname, path, chroot_path);
    1936. 

  1936. 

  1937.     while (*path && flag) {
    1938. 

  1938. 	current = start;
    1939. 

  1939. 	while (current && flag) {
    1940. 

  1940. 	    if (strcmp(current->mnt_dir, "swap")) {
    1941. 

  1941. 		wu_realpath(current->mnt_dir, mnt_dir, chroot_path);
    1942. 

  1942. 		if (!strcmp(mnt_dir, path)) {
    1943. 

  1943. 		    flag = 0;
    1944. 

  1944. 		    /* no support for remote quota yet */
    1945. 

  1945. 		    if (!strchr(current->mnt_fsname, ':'))
    1946. 

  1946. 			strcpy(result, current->mnt_fsname);
    1947. 

  1947. 		}
    1948. 

  1948. 	    }
    1949. 

  1949. 	    current = current->next;
    1950. 

  1950. 	}
    1951. 

  1951. 	if (!((pos = strrchr(path, '/')) - path) && strlen(path) > 1)
    1952. 

  1952. 	    strcpy(path, "/");
    1953. 

  1953. 	else
    1954. 

  1954. 	    path[pos - path] = '\0';
    1955. 

  1955.     }
    1956. 

  1956.     while (current) {
    1957. 

  1957. 	new = current->next;
    1958. 

  1958. 	free(current);
    1959. 

  1959. 	current = new;
    1960. 

  1960.     }
    1961. 

  1961.     return 1;
    1962. 

  1962. }
    1963. 

  1963. #endif
    1964. 

  1964. 

  1965. void get_quota(char *fs, int uid)
    1966. 

  1966. {
    1967. 

  1967.     char mnt_fsname[MNTMAXSTR];
    1968. 

  1968. #ifdef HAS_NO_QUOTACTL
    1969. 

  1969.     int dirfd;
    1970. 

  1970.     struct quotctl qp;
    1971. 

  1971. #endif
    1972. 

  1972. 

  1973.     /*
    1974. 

  1974.      * Getting file system quota information can take a noticeable amount
    1975. 

  1975.      * of time, so only get quota information for specified users.
    1976. 

  1976.      * quota-info <uid-range> [<uid-range> ...]
    1977. 

  1977.      */
    1978. 

  1978.     if (!uid_match("quota-info", uid))
    1979. 

  1979. 	return;
    1980. 

  1980. 

  1981. #ifdef HAS_NO_QUOTACTL
    1982. 

  1982.     if (path_to_device(fs, mnt_fsname)) {
    1983. 

  1983. 	dirfd = open(fs, O_RDONLY);
    1984. 

  1984. 	qp.op = Q_GETQUOTA;
    1985. 

  1985. 	qp.uid = uid;
    1986. 

  1986. 	qp.addr = (char *) &quota;
    1987. 

  1987. 	ioctl(dirfd, Q_QUOTACTL, &qp);
    1988. 

  1988. 	close(dirfd);
    1989. 

  1989.     }
    1990. 

  1990. #else
    1991. 

  1991. #ifdef QUOTA_DEVICE
    1992. 

  1992. 

  1993.     if (path_to_device(fs, mnt_fsname))
    1994. 

  1994. #ifdef QCMD
    1995. 

  1995. 	quotactl(QCMD(Q_GETQUOTA, USRQUOTA), mnt_fsname, uid, (char *) &quota);
    1996. 

  1996. #else
    1997. 

  1997. 	quotactl(Q_GETQUOTA, mnt_fsname, uid, (char *) &quota);
    1998. 

  1998. #endif
    1999. 

  1999. #else
    2000. 

  2000.     quotactl(fs, QCMD(Q_GETQUOTA, USRQUOTA), uid, (char *) &quota);
    2001. 

  2001. #endif
    2002. 

  2002. #endif /* HAS_NO_QUOTACTL */
    2003. 

  2003. }
    2004. 

  2004. 

  2005. char *time_quota(long curstate,…
    2006.

Large files files are truncated, but you can click here to view the full file