1/*	$NetBSD: conf.c,v 1.57 2006/02/01 14:20:12 christos Exp $	*/
2
3/*-
4 * Copyright (c) 1997-2005 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Simon Burge and Luke Mewburn.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 * 3. All advertising materials mentioning features or use of this software
19 *    must display the following acknowledgement:
20 *        This product includes software developed by the NetBSD
21 *        Foundation, Inc. and its contributors.
22 * 4. Neither the name of The NetBSD Foundation nor the names of its
23 *    contributors may be used to endorse or promote products derived
24 *    from this software without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 * POSSIBILITY OF SUCH DAMAGE.
37 */
38
39#include <sys/cdefs.h>
40#ifndef lint
41__RCSID("$NetBSD: conf.c,v 1.57 2006/02/01 14:20:12 christos Exp $");
42#endif /* not lint */
43
44#include <sys/types.h>
45#include <sys/param.h>
46#include <sys/socket.h>
47#include <sys/stat.h>
48
49#include <ctype.h>
50#include <errno.h>
51#include <fcntl.h>
52#include <glob.h>
53#include <netdb.h>
54#include <signal.h>
55#include <stdio.h>
56#include <stdlib.h>
57#include <string.h>
58#include <stringlist.h>
59#include <syslog.h>
60#include <time.h>
61#include <unistd.h>
62#include <util.h>
63
64#ifdef KERBEROS5
65#include <krb5/krb5.h>
66#endif
67
68#include "extern.h"
69#include "pathnames.h"
70
71static char *strend(const char *, char *);
72static int filetypematch(char *, int);
73
74
75		/* class defaults */
76#define DEFAULT_LIMIT		-1		/* unlimited connections */
77#define DEFAULT_MAXFILESIZE	-1		/* unlimited file size */
78#define DEFAULT_MAXTIMEOUT	7200		/* 2 hours */
79#define DEFAULT_TIMEOUT		900		/* 15 minutes */
80#define DEFAULT_UMASK		027		/* rw-r----- */
81
82/*
83 * Initialise curclass to an `empty' state
84 */
85void
86init_curclass(void)
87{
88	struct ftpconv	*conv, *cnext;
89
90	for (conv = curclass.conversions; conv != NULL; conv = cnext) {
91		REASSIGN(conv->suffix, NULL);
92		REASSIGN(conv->types, NULL);
93		REASSIGN(conv->disable, NULL);
94		REASSIGN(conv->command, NULL);
95		cnext = conv->next;
96		free(conv);
97	}
98
99	memset((char *)&curclass.advertise, 0, sizeof(curclass.advertise));
100	curclass.advertise.su_len = 0;		/* `not used' */
101	REASSIGN(curclass.chroot, NULL);
102	REASSIGN(curclass.classname, NULL);
103	curclass.conversions =	NULL;
104	REASSIGN(curclass.display, NULL);
105	REASSIGN(curclass.homedir, NULL);
106	curclass.limit =	DEFAULT_LIMIT;
107	REASSIGN(curclass.limitfile, NULL);
108	curclass.maxfilesize =	DEFAULT_MAXFILESIZE;
109	curclass.maxrateget =	0;
110	curclass.maxrateput =	0;
111	curclass.maxtimeout =	DEFAULT_MAXTIMEOUT;
112	REASSIGN(curclass.motd, ftpd_strdup(_NAME_FTPLOGINMESG));
113	REASSIGN(curclass.notify, NULL);
114	curclass.portmin =	0;
115	curclass.portmax =	0;
116	curclass.rateget =	0;
117	curclass.rateput =	0;
118	curclass.timeout =	DEFAULT_TIMEOUT;
119	    /* curclass.type is set elsewhere */
120	curclass.umask =	DEFAULT_UMASK;
121	curclass.mmapsize =	0;
122	curclass.readsize =	0;
123	curclass.writesize =	0;
124	curclass.sendbufsize =	0;
125	curclass.sendlowat =	0;
126
127	CURCLASS_FLAGS_SET(checkportcmd);
128	CURCLASS_FLAGS_CLR(denyquick);
129	CURCLASS_FLAGS_CLR(hidesymlinks);
130	CURCLASS_FLAGS_SET(modify);
131	CURCLASS_FLAGS_SET(passive);
132	CURCLASS_FLAGS_CLR(private);
133	CURCLASS_FLAGS_CLR(sanenames);
134	CURCLASS_FLAGS_SET(upload);
135}
136
137/*
138 * Parse the configuration file, looking for the named class, and
139 * define curclass to contain the appropriate settings.
140 */
141void
142parse_conf(const char *findclass)
143{
144	FILE		*f;
145	char		*buf, *p;
146	size_t		 len;
147	LLT		 llval;
148	int		 none, match;
149	char		*endp, errbuf[100];
150	char		*class, *word, *arg, *template;
151	const char	*infile;
152	size_t		 line;
153	struct ftpconv	*conv, *cnext;
154
155	init_curclass();
156	REASSIGN(curclass.classname, ftpd_strdup(findclass));
157			/* set more guest defaults */
158	if (strcasecmp(findclass, "guest") == 0) {
159		CURCLASS_FLAGS_CLR(modify);
160		curclass.umask = 0707;
161	}
162
163	infile = conffilename(_NAME_FTPDCONF);
164	if ((f = fopen(infile, "r")) == NULL)
165		return;
166
167	line = 0;
168	template = NULL;
169	for (;
170	    (buf = fparseln(f, &len, &line, NULL, FPARSELN_UNESCCOMM |
171			    FPARSELN_UNESCCONT | FPARSELN_UNESCESC)) != NULL;
172	    free(buf)) {
173		none = match = 0;
174		p = buf;
175		if (len < 1)
176			continue;
177		if (p[len - 1] == '\n')
178			p[--len] = '\0';
179		if (EMPTYSTR(p))
180			continue;
181
182		NEXTWORD(p, word);
183		NEXTWORD(p, class);
184		NEXTWORD(p, arg);
185		if (EMPTYSTR(word) || EMPTYSTR(class))
186			continue;
187		if (strcasecmp(class, "none") == 0)
188			none = 1;
189		if (! (strcasecmp(class, findclass) == 0 ||
190		       (template != NULL && strcasecmp(class, template) == 0) ||
191		       none ||
192		       strcasecmp(class, "all") == 0) )
193			continue;
194
195#define CONF_FLAG(Field)						\
196	do {								\
197		if (none ||						\
198		    (!EMPTYSTR(arg) && strcasecmp(arg, "off") == 0))	\
199			CURCLASS_FLAGS_CLR(Field);			\
200		else							\
201			CURCLASS_FLAGS_SET(Field);			\
202	} while (0)
203
204#define CONF_STRING(Field)						\
205	do {								\
206		if (none || EMPTYSTR(arg))				\
207			arg = NULL;					\
208		else							\
209			arg = ftpd_strdup(arg);				\
210		REASSIGN(curclass.Field, arg);				\
211	} while (0)
212
213#define CONF_LL(Field,Arg,Min,Max)					\
214	do {								\
215		if (none || EMPTYSTR(Arg))				\
216			goto nextline;					\
217		llval = strsuftollx(#Field, Arg, Min, Max,		\
218		    errbuf, sizeof(errbuf));				\
219		if (errbuf[0]) {					\
220			syslog(LOG_WARNING, "%s line %d: %s",		\
221			    infile, (int)line, errbuf);			\
222			goto nextline;					\
223		}							\
224		curclass.Field = llval;					\
225	} while(0)
226
227		if (0)  {
228			/* no-op */
229
230		} else if ((strcasecmp(word, "advertise") == 0)
231			|| (strcasecmp(word, "advertize") == 0)) {
232			struct addrinfo	hints, *res;
233			int		error;
234
235			memset((char *)&curclass.advertise, 0,
236			    sizeof(curclass.advertise));
237			curclass.advertise.su_len = 0;
238			if (none || EMPTYSTR(arg))
239				continue;
240			res = NULL;
241			memset(&hints, 0, sizeof(hints));
242					/*
243					 * only get addresses of the family
244					 * that we're listening on
245					 */
246			hints.ai_family = ctrl_addr.su_family;
247			hints.ai_socktype = SOCK_STREAM;
248			error = getaddrinfo(arg, "0", &hints, &res);
249			if (error) {
250				syslog(LOG_WARNING, "%s line %d: %s",
251				    infile, (int)line, gai_strerror(error));
252 advertiseparsefail:
253				if (res)
254					freeaddrinfo(res);
255				continue;
256			}
257			if (res->ai_next) {
258				syslog(LOG_WARNING,
259    "%s line %d: multiple addresses returned for `%s'; please be more specific",
260				    infile, (int)line, arg);
261				goto advertiseparsefail;
262			}
263			if (sizeof(curclass.advertise) < res->ai_addrlen || (
264#ifdef INET6
265			    res->ai_family != AF_INET6 &&
266#endif
267			    res->ai_family != AF_INET)) {
268				syslog(LOG_WARNING,
269    "%s line %d: unsupported protocol %d for `%s'",
270				    infile, (int)line, res->ai_family, arg);
271				goto advertiseparsefail;
272			}
273			memcpy(&curclass.advertise, res->ai_addr,
274			    res->ai_addrlen);
275			curclass.advertise.su_len = res->ai_addrlen;
276			freeaddrinfo(res);
277
278		} else if (strcasecmp(word, "checkportcmd") == 0) {
279			CONF_FLAG(checkportcmd);
280
281		} else if (strcasecmp(word, "chroot") == 0) {
282			CONF_STRING(chroot);
283
284		} else if (strcasecmp(word, "classtype") == 0) {
285			if (!none && !EMPTYSTR(arg)) {
286				if (strcasecmp(arg, "GUEST") == 0)
287					curclass.type = CLASS_GUEST;
288				else if (strcasecmp(arg, "CHROOT") == 0)
289					curclass.type = CLASS_CHROOT;
290				else if (strcasecmp(arg, "REAL") == 0)
291					curclass.type = CLASS_REAL;
292				else {
293					syslog(LOG_WARNING,
294				    "%s line %d: unknown class type `%s'",
295					    infile, (int)line, arg);
296					continue;
297				}
298			}
299
300		} else if (strcasecmp(word, "conversion") == 0) {
301			char *suffix, *types, *disable, *convcmd;
302
303			if (EMPTYSTR(arg)) {
304				syslog(LOG_WARNING,
305				    "%s line %d: %s requires a suffix",
306				    infile, (int)line, word);
307				continue;	/* need a suffix */
308			}
309			NEXTWORD(p, types);
310			NEXTWORD(p, disable);
311			convcmd = p;
312			if (convcmd)
313				convcmd += strspn(convcmd, " \t");
314			suffix = ftpd_strdup(arg);
315			if (none || EMPTYSTR(types) ||
316			    EMPTYSTR(disable) || EMPTYSTR(convcmd)) {
317				types = NULL;
318				disable = NULL;
319				convcmd = NULL;
320			} else {
321				types = ftpd_strdup(types);
322				disable = ftpd_strdup(disable);
323				convcmd = ftpd_strdup(convcmd);
324			}
325			for (conv = curclass.conversions; conv != NULL;
326			    conv = conv->next) {
327				if (strcmp(conv->suffix, suffix) == 0)
328					break;
329			}
330			if (conv == NULL) {
331				conv = (struct ftpconv *)
332				    calloc(1, sizeof(struct ftpconv));
333				if (conv == NULL) {
334					syslog(LOG_WARNING, "can't malloc");
335					continue;
336				}
337				conv->next = NULL;
338				for (cnext = curclass.conversions;
339				    cnext != NULL; cnext = cnext->next)
340					if (cnext->next == NULL)
341						break;
342				if (cnext != NULL)
343					cnext->next = conv;
344				else
345					curclass.conversions = conv;
346			}
347			REASSIGN(conv->suffix, suffix);
348			REASSIGN(conv->types, types);
349			REASSIGN(conv->disable, disable);
350			REASSIGN(conv->command, convcmd);
351
352		} else if (strcasecmp(word, "denyquick") == 0) {
353			CONF_FLAG(denyquick);
354
355		} else if (strcasecmp(word, "display") == 0) {
356			CONF_STRING(display);
357
358		} else if (strcasecmp(word, "hidesymlinks") == 0) {
359			CONF_FLAG(hidesymlinks);
360
361		} else if (strcasecmp(word, "homedir") == 0) {
362			CONF_STRING(homedir);
363
364		} else if (strcasecmp(word, "limit") == 0) {
365			curclass.limit = DEFAULT_LIMIT;
366			REASSIGN(curclass.limitfile, NULL);
367			CONF_LL(limit, arg, -1, LLTMAX);
368			REASSIGN(curclass.limitfile,
369			    EMPTYSTR(p) ? NULL : ftpd_strdup(p));
370
371		} else if (strcasecmp(word, "maxfilesize") == 0) {
372			curclass.maxfilesize = DEFAULT_MAXFILESIZE;
373			CONF_LL(maxfilesize, arg, -1, LLTMAX);
374
375		} else if (strcasecmp(word, "maxtimeout") == 0) {
376			curclass.maxtimeout = DEFAULT_MAXTIMEOUT;
377			CONF_LL(maxtimeout, arg,
378			    MIN(30, curclass.timeout), LLTMAX);
379
380		} else if (strcasecmp(word, "mmapsize") == 0) {
381			curclass.mmapsize = 0;
382			CONF_LL(mmapsize, arg, 0, LLTMAX);
383
384		} else if (strcasecmp(word, "readsize") == 0) {
385			curclass.readsize = 0;
386			CONF_LL(readsize, arg, 0, LLTMAX);
387
388		} else if (strcasecmp(word, "writesize") == 0) {
389			curclass.writesize = 0;
390			CONF_LL(writesize, arg, 0, LLTMAX);
391
392		} else if (strcasecmp(word, "recvbufsize") == 0) {
393			curclass.recvbufsize = 0;
394			CONF_LL(recvbufsize, arg, 0, LLTMAX);
395
396		} else if (strcasecmp(word, "sendbufsize") == 0) {
397			curclass.sendbufsize = 0;
398			CONF_LL(sendbufsize, arg, 0, LLTMAX);
399
400		} else if (strcasecmp(word, "sendlowat") == 0) {
401			curclass.sendlowat = 0;
402			CONF_LL(sendlowat, arg, 0, LLTMAX);
403
404		} else if (strcasecmp(word, "modify") == 0) {
405			CONF_FLAG(modify);
406
407		} else if (strcasecmp(word, "motd") == 0) {
408			CONF_STRING(motd);
409
410		} else if (strcasecmp(word, "notify") == 0) {
411			CONF_STRING(notify);
412
413		} else if (strcasecmp(word, "passive") == 0) {
414			CONF_FLAG(passive);
415
416		} else if (strcasecmp(word, "portrange") == 0) {
417			long minport, maxport;
418
419			curclass.portmin = 0;
420			curclass.portmax = 0;
421			if (none || EMPTYSTR(arg))
422				continue;
423			if (EMPTYSTR(p)) {
424				syslog(LOG_WARNING,
425				   "%s line %d: missing maxport argument",
426				   infile, (int)line);
427				continue;
428			}
429			minport = strsuftollx("minport", arg, IPPORT_RESERVED,
430			    IPPORT_ANONMAX, errbuf, sizeof(errbuf));
431			if (errbuf[0]) {
432				syslog(LOG_WARNING, "%s line %d: %s",
433				    infile, (int)line, errbuf);
434				continue;
435			}
436			maxport = strsuftollx("maxport", p, IPPORT_RESERVED,
437			    IPPORT_ANONMAX, errbuf, sizeof(errbuf));
438			if (errbuf[0]) {
439				syslog(LOG_WARNING, "%s line %d: %s",
440				    infile, (int)line, errbuf);
441				continue;
442			}
443			if (minport >= maxport) {
444				syslog(LOG_WARNING,
445				    "%s line %d: minport %ld >= maxport %ld",
446				    infile, (int)line, minport, maxport);
447				continue;
448			}
449			curclass.portmin = (int)minport;
450			curclass.portmax = (int)maxport;
451
452		} else if (strcasecmp(word, "private") == 0) {
453			CONF_FLAG(private);
454
455		} else if (strcasecmp(word, "rateget") == 0) {
456			curclass.maxrateget = curclass.rateget = 0;
457			CONF_LL(rateget, arg, 0, LLTMAX);
458			curclass.maxrateget = curclass.rateget;
459
460		} else if (strcasecmp(word, "rateput") == 0) {
461			curclass.maxrateput = curclass.rateput = 0;
462			CONF_LL(rateput, arg, 0, LLTMAX);
463			curclass.maxrateput = curclass.rateput;
464
465		} else if (strcasecmp(word, "sanenames") == 0) {
466			CONF_FLAG(sanenames);
467
468		} else if (strcasecmp(word, "timeout") == 0) {
469			curclass.timeout = DEFAULT_TIMEOUT;
470			CONF_LL(timeout, arg, 30, curclass.maxtimeout);
471
472		} else if (strcasecmp(word, "template") == 0) {
473			if (none)
474				continue;
475			REASSIGN(template, EMPTYSTR(arg) ? NULL : ftpd_strdup(arg));
476
477		} else if (strcasecmp(word, "umask") == 0) {
478			u_long fumask;
479
480			curclass.umask = DEFAULT_UMASK;
481			if (none || EMPTYSTR(arg))
482				continue;
483			errno = 0;
484			endp = NULL;
485			fumask = strtoul(arg, &endp, 8);
486			if (errno || *arg == '\0' || *endp != '\0' ||
487			    fumask > 0777) {
488				syslog(LOG_WARNING,
489				    "%s line %d: invalid umask %s",
490				    infile, (int)line, arg);
491				continue;
492			}
493			curclass.umask = (mode_t)fumask;
494
495		} else if (strcasecmp(word, "upload") == 0) {
496			CONF_FLAG(upload);
497			if (! CURCLASS_FLAGS_ISSET(upload))
498				CURCLASS_FLAGS_CLR(modify);
499
500		} else {
501			syslog(LOG_WARNING,
502			    "%s line %d: unknown directive '%s'",
503			    infile, (int)line, word);
504			continue;
505		}
506 nextline:
507		;
508	}
509	REASSIGN(template, NULL);
510	fclose(f);
511}
512
513/*
514 * Show file listed in curclass.display first time in, and list all the
515 * files named in curclass.notify in the current directory.
516 * Send back responses with the prefix `code' + "-".
517 * If code == -1, flush the internal cache of directory names and return.
518 */
519void
520show_chdir_messages(int code)
521{
522	static StringList *slist = NULL;
523
524	struct stat st;
525	struct tm *t;
526	glob_t	 gl;
527	time_t	 now, then;
528	int	 age;
529	char	 curwd[MAXPATHLEN];
530	char	*cp, **rlist;
531
532	if (code == -1) {
533		if (slist != NULL)
534			sl_free(slist, 1);
535		slist = NULL;
536		return;
537	}
538
539	if (quietmessages)
540		return;
541
542		/* Setup list for directory cache */
543	if (slist == NULL)
544		slist = sl_init();
545	if (slist == NULL) {
546		syslog(LOG_WARNING, "can't allocate memory for stringlist");
547		return;
548	}
549
550		/* Check if this directory has already been visited */
551	if (getcwd(curwd, sizeof(curwd) - 1) == NULL) {
552		syslog(LOG_WARNING, "can't getcwd: %s", strerror(errno));
553		return;
554	}
555	if (sl_find(slist, curwd) != NULL)
556		return;
557
558	cp = ftpd_strdup(curwd);
559	if (sl_add(slist, cp) == -1)
560		syslog(LOG_WARNING, "can't add `%s' to stringlist", cp);
561
562		/* First check for a display file */
563	(void)display_file(curclass.display, code);
564
565		/* Now see if there are any notify files */
566	if (EMPTYSTR(curclass.notify))
567		return;
568
569	memset(&gl, 0, sizeof(gl));
570	if (glob(curclass.notify, GLOB_BRACE|GLOB_LIMIT, NULL, &gl) != 0
571	    || gl.gl_matchc == 0) {
572		globfree(&gl);
573		return;
574	}
575	time(&now);
576	for (rlist = gl.gl_pathv; *rlist != NULL; rlist++) {
577		if (stat(*rlist, &st) != 0)
578			continue;
579		if (!S_ISREG(st.st_mode))
580			continue;
581		then = st.st_mtime;
582		if (code != 0) {
583			reply(-code, "%s", "");
584			code = 0;
585		}
586		reply(-code, "Please read the file %s", *rlist);
587		t = localtime(&now);
588		age = 365 * t->tm_year + t->tm_yday;
589		t = localtime(&then);
590		age -= 365 * t->tm_year + t->tm_yday;
591		reply(-code, "  it was last modified on %.24s - %d day%s ago",
592		    ctime(&then), age, PLURAL(age));
593	}
594	globfree(&gl);
595}
596
597int
598display_file(const char *file, int code)
599{
600	FILE   *f;
601	char   *buf, *p;
602	char	curwd[MAXPATHLEN];
603	size_t	len;
604	off_t	lastnum;
605	time_t	now;
606
607	lastnum = 0;
608	if (quietmessages)
609		return (0);
610
611	if (EMPTYSTR(file))
612		return(0);
613	if ((f = fopen(file, "r")) == NULL)
614		return (0);
615	reply(-code, "%s", "");
616
617	for (;
618	    (buf = fparseln(f, &len, NULL, "\0\0\0", 0)) != NULL; free(buf)) {
619		if (len > 0)
620			if (buf[len - 1] == '\n')
621				buf[--len] = '\0';
622		cprintf(stdout, "    ");
623
624		for (p = buf; *p; p++) {
625			if (*p == '%') {
626				p++;
627				switch (*p) {
628
629				case 'c':
630					cprintf(stdout, "%s",
631					    curclass.classname ?
632					    curclass.classname : "<unknown>");
633					break;
634
635				case 'C':
636					if (getcwd(curwd, sizeof(curwd)-1)
637					    == NULL){
638						syslog(LOG_WARNING,
639						    "can't getcwd: %s",
640						    strerror(errno));
641						continue;
642					}
643					cprintf(stdout, "%s", curwd);
644					break;
645
646				case 'E':
647					if (! EMPTYSTR(emailaddr))
648						cprintf(stdout, "%s",
649						    emailaddr);
650					break;
651
652				case 'L':
653					cprintf(stdout, "%s", hostname);
654					break;
655
656				case 'M':
657					if (curclass.limit == -1) {
658						cprintf(stdout, "unlimited");
659						lastnum = 0;
660					} else {
661						cprintf(stdout, LLF,
662						    (LLT)curclass.limit);
663						lastnum = curclass.limit;
664					}
665					break;
666
667				case 'N':
668					cprintf(stdout, "%d", connections);
669					lastnum = connections;
670					break;
671
672				case 'R':
673					cprintf(stdout, "%s", remotehost);
674					break;
675
676				case 's':
677					if (lastnum != 1)
678						cprintf(stdout, "s");
679					break;
680
681				case 'S':
682					if (lastnum != 1)
683						cprintf(stdout, "S");
684					break;
685
686				case 'T':
687					now = time(NULL);
688					cprintf(stdout, "%.24s", ctime(&now));
689					break;
690
691				case 'U':
692					cprintf(stdout, "%s",
693					    pw ? pw->pw_name : "<unknown>");
694					break;
695
696				case '%':
697					CPUTC('%', stdout);
698					break;
699
700				}
701			} else
702				CPUTC(*p, stdout);
703		}
704		cprintf(stdout, "\r\n");
705	}
706
707	(void)fflush(stdout);
708	(void)fclose(f);
709	return (1);
710}
711
712/*
713 * Parse src, expanding '%' escapes, into dst (which must be at least
714 * MAXPATHLEN long).
715 */
716void
717format_path(char *dst, const char *src)
718{
719	size_t len;
720	const char *p;
721
722	dst[0] = '\0';
723	len = 0;
724	if (src == NULL)
725		return;
726	for (p = src; *p && len < MAXPATHLEN; p++) {
727		if (*p == '%') {
728			p++;
729			switch (*p) {
730
731			case 'c':
732				len += strlcpy(dst + len, curclass.classname,
733				    MAXPATHLEN - len);
734				break;
735
736			case 'd':
737				len += strlcpy(dst + len, pw->pw_dir,
738				    MAXPATHLEN - len);
739				break;
740
741			case 'u':
742				len += strlcpy(dst + len, pw->pw_name,
743				    MAXPATHLEN - len);
744				break;
745
746			case '%':
747				dst[len++] = '%';
748				break;
749
750			}
751		} else
752			dst[len++] = *p;
753	}
754	if (len < MAXPATHLEN)
755		dst[len] = '\0';
756	dst[MAXPATHLEN - 1] = '\0';
757}
758
759/*
760 * Find s2 at the end of s1.  If found, return a string up to (but
761 * not including) s2, otherwise returns NULL.
762 */
763static char *
764strend(const char *s1, char *s2)
765{
766	static	char buf[MAXPATHLEN];
767
768	char	*start;
769	size_t	l1, l2;
770
771	l1 = strlen(s1);
772	l2 = strlen(s2);
773
774	if (l2 >= l1 || l1 >= sizeof(buf))
775		return(NULL);
776
777	strlcpy(buf, s1, sizeof(buf));
778	start = buf + (l1 - l2);
779
780	if (strcmp(start, s2) == 0) {
781		*start = '\0';
782		return(buf);
783	} else
784		return(NULL);
785}
786
787static int
788filetypematch(char *types, int mode)
789{
790	for ( ; types[0] != '\0'; types++)
791		switch (*types) {
792		  case 'd':
793			if (S_ISDIR(mode))
794				return(1);
795			break;
796		  case 'f':
797			if (S_ISREG(mode))
798				return(1);
799			break;
800		}
801	return(0);
802}
803
804/*
805 * Look for a conversion.  If we succeed, return a pointer to the
806 * command to execute for the conversion.
807 *
808 * The command is stored in a static array so there's no memory
809 * leak problems, and not too much to change in ftpd.c.  This
810 * routine doesn't need to be re-entrant unless we start using a
811 * multi-threaded ftpd, and that's not likely for a while...
812 */
813char **
814do_conversion(const char *fname)
815{
816	struct ftpconv	*cp;
817	struct stat	 st;
818	int		 o_errno;
819	char		*base = NULL;
820	char		*cmd, *p, *lp, **argv;
821	StringList	*sl;
822
823	o_errno = errno;
824	sl = NULL;
825	cmd = NULL;
826	for (cp = curclass.conversions; cp != NULL; cp = cp->next) {
827		if (cp->suffix == NULL) {
828			syslog(LOG_WARNING,
829			    "cp->suffix==NULL in conv list; SHOULDN'T HAPPEN!");
830			continue;
831		}
832		if ((base = strend(fname, cp->suffix)) == NULL)
833			continue;
834		if (cp->types == NULL || cp->disable == NULL ||
835		    cp->command == NULL)
836			continue;
837					/* Is it enabled? */
838		if (strcmp(cp->disable, ".") != 0 &&
839		    stat(cp->disable, &st) == 0)
840				continue;
841					/* Does the base exist? */
842		if (stat(base, &st) < 0)
843			continue;
844					/* Is the file type ok */
845		if (!filetypematch(cp->types, st.st_mode))
846			continue;
847		break;			/* "We have a winner!" */
848	}
849
850	/* If we got through the list, no conversion */
851	if (cp == NULL)
852		goto cleanup_do_conv;
853
854	/* Split up command into an argv */
855	if ((sl = sl_init()) == NULL)
856		goto cleanup_do_conv;
857	cmd = ftpd_strdup(cp->command);
858	p = cmd;
859	while (p) {
860		NEXTWORD(p, lp);
861		if (strcmp(lp, "%s") == 0)
862			lp = base;
863		if (sl_add(sl, ftpd_strdup(lp)) == -1)
864			goto cleanup_do_conv;
865	}
866
867	if (sl_add(sl, NULL) == -1)
868		goto cleanup_do_conv;
869	argv = sl->sl_str;
870	free(cmd);
871	free(sl);
872	return(argv);
873
874 cleanup_do_conv:
875	if (sl)
876		sl_free(sl, 1);
877	free(cmd);
878	errno = o_errno;
879	return(NULL);
880}
881
882/*
883 * Count the number of current connections, reading from
884 *	/var/run/ftpd.pids-<class>
885 * Does a kill -0 on each pid in that file, and only counts
886 * processes that exist (or frees the slot if it doesn't).
887 * Adds getpid() to the first free slot. Truncates the file
888 * if possible.
889 */
890void
891count_users(void)
892{
893	char	fn[MAXPATHLEN];
894	int	fd, i, last;
895	size_t	count;
896	pid_t  *pids, mypid;
897	struct stat sb;
898
899	(void)strlcpy(fn, _PATH_CLASSPIDS, sizeof(fn));
900	(void)strlcat(fn, curclass.classname, sizeof(fn));
901	pids = NULL;
902	connections = 1;
903
904	if ((fd = open(fn, O_RDWR | O_CREAT, 0600)) == -1)
905		return;
906	if (lockf(fd, F_TLOCK, 0) == -1)
907		goto cleanup_count;
908	if (fstat(fd, &sb) == -1)
909		goto cleanup_count;
910	if ((pids = malloc(sb.st_size + sizeof(pid_t))) == NULL)
911		goto cleanup_count;
912	count = read(fd, pids, sb.st_size);
913	if (count < 0 || count != sb.st_size)
914		goto cleanup_count;
915	count /= sizeof(pid_t);
916	mypid = getpid();
917	last = 0;
918	for (i = 0; i < count; i++) {
919		if (pids[i] == 0)
920			continue;
921		if (kill(pids[i], 0) == -1 && errno != EPERM) {
922			if (mypid != 0) {
923				pids[i] = mypid;
924				mypid = 0;
925				last = i;
926			}
927		} else {
928			connections++;
929			last = i;
930		}
931	}
932	if (mypid != 0) {
933		if (pids[last] != 0)
934			last++;
935		pids[last] = mypid;
936	}
937	count = (last + 1) * sizeof(pid_t);
938	if (lseek(fd, 0, SEEK_SET) == -1)
939		goto cleanup_count;
940	if (write(fd, pids, count) == -1)
941		goto cleanup_count;
942	(void)ftruncate(fd, count);
943
944 cleanup_count:
945	if (lseek(fd, 0, SEEK_SET) != -1)
946		(void)lockf(fd, F_ULOCK, 0);
947	close(fd);
948	REASSIGN(pids, NULL);
949}
950