The first a bug in pax and should be commited to FBSD, too.
[dragonfly.git] / contrib / lukemftpd / src / cmds.c
1 /*      $NetBSD: cmds.c,v 1.16 2002/02/13 15:15:23 lukem Exp $  */
2
3 /*
4  * Copyright (c) 1999-2001 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by 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 /*
40  * Copyright (c) 1985, 1988, 1990, 1992, 1993, 1994
41  *      The Regents of the University of California.  All rights reserved.
42  *
43  * Redistribution and use in source and binary forms, with or without
44  * modification, are permitted provided that the following conditions
45  * are met:
46  * 1. Redistributions of source code must retain the above copyright
47  *    notice, this list of conditions and the following disclaimer.
48  * 2. Redistributions in binary form must reproduce the above copyright
49  *    notice, this list of conditions and the following disclaimer in the
50  *    documentation and/or other materials provided with the distribution.
51  * 3. All advertising materials mentioning features or use of this software
52  *    must display the following acknowledgement:
53  *      This product includes software developed by the University of
54  *      California, Berkeley and its contributors.
55  * 4. Neither the name of the University nor the names of its contributors
56  *    may be used to endorse or promote products derived from this software
57  *    without specific prior written permission.
58  *
59  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
60  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
61  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
62  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
63  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
64  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
65  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
66  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
67  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
68  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
69  * SUCH DAMAGE.
70  */
71
72 /*
73  * Copyright (C) 1997 and 1998 WIDE Project.
74  * All rights reserved.
75  * 
76  * Redistribution and use in source and binary forms, with or without
77  * modification, are permitted provided that the following conditions
78  * are met:
79  * 1. Redistributions of source code must retain the above copyright
80  *    notice, this list of conditions and the following disclaimer.
81  * 2. Redistributions in binary form must reproduce the above copyright
82  *    notice, this list of conditions and the following disclaimer in the
83  *    documentation and/or other materials provided with the distribution.
84  * 3. Neither the name of the project nor the names of its contributors
85  *    may be used to endorse or promote products derived from this software
86  *    without specific prior written permission.
87  * 
88  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
89  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
90  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
91  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
92  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
93  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
94  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
95  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
96  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
97  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
98  * SUCH DAMAGE.
99  */
100
101 #include "lukemftpd.h"
102
103 #include "extern.h"
104
105 typedef enum {
106         FE_MLSD         = 1<<0,         /* if op is MLSD (MLST otherwise ) */
107         FE_ISCURDIR     = 1<<1,         /* if name is the current directory */
108 } factflag_t;
109
110 typedef struct {
111         const char      *path;          /* full pathname */
112         const char      *display;       /* name to display */
113         struct stat     *stat;          /* stat of path */
114         struct stat     *pdirstat;      /* stat of path's parent dir */
115         factflag_t       flags;         /* flags */
116 } factelem;
117
118 static void     ack(const char *);
119 static void     base64_encode(const char *, size_t, char *, int);
120 static void     fact_type(const char *, FILE *, factelem *);
121 static void     fact_size(const char *, FILE *, factelem *);
122 static void     fact_modify(const char *, FILE *, factelem *);
123 static void     fact_perm(const char *, FILE *, factelem *);
124 static void     fact_unique(const char *, FILE *, factelem *);
125 static int      matchgroup(gid_t);
126 static void     mlsname(FILE *, factelem *);
127 static void     replydirname(const char *, const char *);
128
129 struct ftpfact {
130         const char       *name;         /* name of fact */
131         int               enabled;      /* if fact is enabled */
132         void            (*display)(const char *, FILE *, factelem *);
133                                         /* function to display fact */
134 };
135
136 struct ftpfact facttab[] = {
137         { "Type",       1, fact_type },
138 #define FACT_TYPE 0
139         { "Size",       1, fact_size },
140         { "Modify",     1, fact_modify },
141         { "Perm",       1, fact_perm },
142         { "Unique",     1, fact_unique },
143         /* "Create" */
144         /* "Lang" */
145         /* "Media-Type" */
146         /* "CharSet" */
147 };
148
149 #define FACTTABSIZE     (sizeof(facttab) / sizeof(struct ftpfact))
150
151
152 void
153 cwd(const char *path)
154 {
155
156         if (chdir(path) < 0)
157                 perror_reply(550, path);
158         else {
159                 show_chdir_messages(250);
160                 ack("CWD");
161         }
162 }
163
164 void
165 delete(const char *name)
166 {
167         char *p = NULL;
168
169         if (remove(name) < 0) {
170                 p = strerror(errno);
171                 perror_reply(550, name);
172         } else
173                 ack("DELE");
174         logxfer("delete", -1, name, NULL, NULL, p);
175 }
176
177 void
178 feat(void)
179 {
180         int i;
181
182         reply(-211, "Features supported");
183         cprintf(stdout, " MDTM\r\n");
184         cprintf(stdout, " MLST ");
185         for (i = 0; i < FACTTABSIZE; i++)
186                 cprintf(stdout, "%s%s;", facttab[i].name,
187                     facttab[i].enabled ? "*" : "");
188         cprintf(stdout, "\r\n");
189         cprintf(stdout, " REST STREAM\r\n");
190         cprintf(stdout, " SIZE\r\n");
191         cprintf(stdout, " TVFS\r\n");
192         reply(211,  "End");
193 }
194
195 void
196 makedir(const char *name)
197 {
198         char *p = NULL;
199
200         if (mkdir(name, 0777) < 0) {
201                 p = strerror(errno);
202                 perror_reply(550, name);
203         } else
204                 replydirname(name, "directory created.");
205         logxfer("mkdir", -1, name, NULL, NULL, p);
206 }
207
208 void
209 mlsd(const char *path)
210 {
211         struct dirent   *dp;
212         struct stat      sb, pdirstat;
213         factelem f;
214         FILE    *dout;
215         DIR     *dirp;
216         char    name[MAXPATHLEN];
217         int     hastypefact;
218
219         hastypefact = facttab[FACT_TYPE].enabled;
220         if (path == NULL)
221                 path = ".";
222         if (stat(path, &pdirstat) == -1) {
223  mlsdperror:
224                 perror_reply(550, path);
225                 return;
226         }
227         if (! S_ISDIR(pdirstat.st_mode)) {
228                 errno = ENOTDIR;
229                 perror_reply(501, path);
230                 return;
231         }
232         if ((dirp = opendir(path)) == NULL)
233                 goto mlsdperror;
234
235         dout = dataconn("MLSD", (off_t)-1, "w");
236         if (dout == NULL)
237                 return;
238
239         memset(&f, 0, sizeof(f));
240         f.stat = &sb;
241         f.flags |= FE_MLSD;
242         while ((dp = readdir(dirp)) != NULL) {
243                 snprintf(name, sizeof(name), "%s/%s", path, dp->d_name);
244                 if (ISDOTDIR(dp->d_name)) {     /* special case curdir: */
245                         if (! hastypefact)
246                                 continue;
247                         f.pdirstat = NULL;      /*   require stat of parent */
248                         f.display = path;       /*   set name to real name */
249                         f.flags |= FE_ISCURDIR; /*   flag name is curdir */
250                 } else {
251                         if (ISDOTDOTDIR(dp->d_name)) {
252                                 if (! hastypefact)
253                                         continue;
254                                 f.pdirstat = NULL;
255                         } else
256                                 f.pdirstat = &pdirstat; /* cache parent stat */
257                         f.display = dp->d_name;
258                         f.flags &= ~FE_ISCURDIR;
259                 }
260                 if (stat(name, &sb) == -1)
261                         continue;
262                 f.path = name;
263                 mlsname(dout, &f);
264         }
265         (void)closedir(dirp);
266
267         if (ferror(dout) != 0)
268                 perror_reply(550, "Data connection");
269         else
270                 reply(226, "MLSD complete.");
271         closedataconn(dout);
272         total_xfers_out++;
273         total_xfers++;
274 }
275
276 void
277 mlst(const char *path)
278 {
279         struct stat sb;
280         factelem f;
281
282         if (path == NULL)
283                 path = ".";
284         if (stat(path, &sb) == -1) {
285                 perror_reply(550, path);
286                 return;
287         }
288         reply(-250, "MLST %s", path);
289         memset(&f, 0, sizeof(f));
290         f.path = path;
291         f.display = path;
292         f.stat = &sb;
293         f.pdirstat = NULL;
294         CPUTC(' ', stdout);
295         mlsname(stdout, &f);
296         reply(250, "End");
297 }
298
299
300 void
301 opts(const char *command)
302 {
303         struct tab *c;
304         char *ep;
305
306         if ((ep = strchr(command, ' ')) != NULL)
307                 *ep++ = '\0';
308         c = lookup(cmdtab, command);
309         if (c == NULL) {
310                 reply(502, "Unknown command %s.", command);
311                 return;
312         }
313         if (! CMD_IMPLEMENTED(c)) {
314                 reply(501, "%s command not implemented.", c->name);
315                 return;
316         }
317         if (! CMD_HAS_OPTIONS(c)) {
318                 reply(501, "%s command does not support persistent options.",
319                     c->name);
320                 return;
321         }
322
323                         /* special case: MLST */
324         if (strcasecmp(command, "MLST") == 0) {
325                 int      enabled[FACTTABSIZE];
326                 int      i, onedone;
327                 size_t   len;
328                 char    *p;
329
330                 for (i = 0; i < sizeof(enabled) / sizeof(int); i++)
331                         enabled[i] = 0;
332                 if (ep == NULL || *ep == '\0')
333                         goto displaymlstopts;
334
335                                 /* don't like spaces, and need trailing ; */
336                 len = strlen(ep);
337                 if (strchr(ep, ' ') != NULL || ep[len - 1] != ';') {
338  badmlstopt:
339                         reply(501, "Invalid MLST options");
340                         return;
341                 }
342                 ep[len - 1] = '\0';
343                 while ((p = strsep(&ep, ";")) != NULL) {
344                         if (*p == '\0')
345                                 goto badmlstopt;
346                         for (i = 0; i < FACTTABSIZE; i++)
347                                 if (strcasecmp(p, facttab[i].name) == 0) {
348                                         enabled[i] = 1;
349                                         break;
350                                 }
351                 }
352
353  displaymlstopts:
354                 for (i = 0; i < FACTTABSIZE; i++)
355                         facttab[i].enabled = enabled[i];
356                 cprintf(stdout, "200 MLST OPTS");
357                 for (i = onedone = 0; i < FACTTABSIZE; i++) {
358                         if (facttab[i].enabled) {
359                                 cprintf(stdout, "%s%s;", onedone ? "" : " ",
360                                     facttab[i].name);
361                                 onedone++;
362                         }
363                 }
364                 cprintf(stdout, "\r\n");
365                 fflush(stdout);
366                 return;
367         }
368
369                         /* default cases */
370         if (ep != NULL && *ep != '\0')
371                 REASSIGN(c->options, xstrdup(ep));
372         if (c->options != NULL)
373                 reply(200, "Options for %s are '%s'.", c->name,
374                     c->options);
375         else
376                 reply(200, "No options defined for %s.", c->name);
377 }
378
379 void
380 pwd(void)
381 {
382         char path[MAXPATHLEN];
383
384         if (getcwd(path, sizeof(path) - 1) == NULL)
385                 reply(550, "Can't get the current directory: %s.",
386                     strerror(errno));
387         else
388                 replydirname(path, "is the current directory.");
389 }
390
391 void
392 removedir(const char *name)
393 {
394         char *p = NULL;
395
396         if (rmdir(name) < 0) {
397                 p = strerror(errno);
398                 perror_reply(550, name);
399         } else
400                 ack("RMD");
401         logxfer("rmdir", -1, name, NULL, NULL, p);
402 }
403
404 char *
405 renamefrom(const char *name)
406 {
407         struct stat st;
408
409         if (stat(name, &st) < 0) {
410                 perror_reply(550, name);
411                 return (NULL);
412         }
413         reply(350, "File exists, ready for destination name");
414         return (xstrdup(name));
415 }
416
417 void
418 renamecmd(const char *from, const char *to)
419 {
420         char *p = NULL;
421
422         if (rename(from, to) < 0) {
423                 p = strerror(errno);
424                 perror_reply(550, "rename");
425         } else
426                 ack("RNTO");
427         logxfer("rename", -1, from, to, NULL, p);
428 }
429
430 void
431 sizecmd(const char *filename)
432 {
433         switch (type) {
434         case TYPE_L:
435         case TYPE_I:
436             {
437                 struct stat stbuf;
438                 if (stat(filename, &stbuf) < 0 || !S_ISREG(stbuf.st_mode))
439                         reply(550, "%s: not a plain file.", filename);
440                 else
441                         reply(213, ULLF, (ULLT)stbuf.st_size);
442                 break;
443             }
444         case TYPE_A:
445             {
446                 FILE *fin;
447                 int c;
448                 off_t count;
449                 struct stat stbuf;
450                 fin = fopen(filename, "r");
451                 if (fin == NULL) {
452                         perror_reply(550, filename);
453                         return;
454                 }
455                 if (fstat(fileno(fin), &stbuf) < 0 || !S_ISREG(stbuf.st_mode)) {
456                         reply(550, "%s: not a plain file.", filename);
457                         (void) fclose(fin);
458                         return;
459                 }
460                 if (stbuf.st_size > 10240) {
461                         reply(550, "%s: file too large for SIZE.", filename);
462                         (void) fclose(fin);
463                         return;
464                 }
465
466                 count = 0;
467                 while((c = getc(fin)) != EOF) {
468                         if (c == '\n')  /* will get expanded to \r\n */
469                                 count++;
470                         count++;
471                 }
472                 (void) fclose(fin);
473
474                 reply(213, LLF, (LLT)count);
475                 break;
476             }
477         default:
478                 reply(504, "SIZE not implemented for Type %c.", "?AEIL"[type]);
479         }
480 }
481
482 void
483 statfilecmd(const char *filename)
484 {
485         FILE *fin;
486         int c;
487         char *argv[] = { INTERNAL_LS, "-lgA", "", NULL };
488
489         argv[2] = (char *)filename;
490         fin = ftpd_popen(argv, "r", STDOUT_FILENO);
491         reply(-211, "status of %s:", filename);
492 /* XXX: use fgetln() or fparseln() here? */
493         while ((c = getc(fin)) != EOF) {
494                 if (c == '\n') {
495                         if (ferror(stdout)){
496                                 perror_reply(421, "control connection");
497                                 (void) ftpd_pclose(fin);
498                                 dologout(1);
499                                 /* NOTREACHED */
500                         }
501                         if (ferror(fin)) {
502                                 perror_reply(551, filename);
503                                 (void) ftpd_pclose(fin);
504                                 return;
505                         }
506                         CPUTC('\r', stdout);
507                 }
508                 CPUTC(c, stdout);
509         }
510         (void) ftpd_pclose(fin);
511         reply(211, "End of Status");
512 }
513
514 /* -- */
515
516 static void
517 ack(const char *s)
518 {
519
520         reply(250, "%s command successful.", s);
521 }
522
523 /*
524  * Encode len bytes starting at clear using base64 encoding into encoded,
525  * which should be at least ((len + 2) * 4 / 3 + 1) in size.
526  * If nulterm is non-zero, terminate with \0 otherwise pad to 3 byte boundary
527  * with `='.
528  */
529 static void
530 base64_encode(const char *clear, size_t len, char *encoded, int nulterm)
531 {
532         static const char base64[] =
533             "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
534         const char *c;
535         char    *e, termchar;
536         int      i;
537
538                         /* determine whether to pad with '=' or NUL terminate */
539         termchar = nulterm ? '\0' : '=';
540         c = clear;
541         e = encoded;
542                         /* convert all but last 2 bytes */
543         for (i = len; i > 2; i -= 3, c += 3) {
544                 *e++ = base64[(c[0] >> 2) & 0x3f];
545                 *e++ = base64[((c[0] << 4) & 0x30) | ((c[1] >> 4) & 0x0f)];
546                 *e++ = base64[((c[1] << 2) & 0x3c) | ((c[2] >> 6) & 0x03)];
547                 *e++ = base64[(c[2]) & 0x3f];
548         }
549                         /* handle slop at end */
550         if (i > 0) {
551                 *e++ = base64[(c[0] >> 2) & 0x3f];
552                 *e++ = base64[((c[0] << 4) & 0x30) |
553                      (i > 1 ? ((c[1] >> 4) & 0x0f) : 0)];
554                 *e++ = (i > 1) ? base64[(c[1] << 2) & 0x3c] : termchar;
555                 *e++ = termchar;
556         }
557         *e = '\0';
558 }
559
560 static void
561 fact_modify(const char *fact, FILE *fd, factelem *fe)
562 {
563         struct tm *t;
564
565         t = gmtime(&(fe->stat->st_mtime));
566         cprintf(fd, "%s=%04d%02d%02d%02d%02d%02d;", fact,
567             TM_YEAR_BASE + t->tm_year,
568             t->tm_mon+1, t->tm_mday,
569             t->tm_hour, t->tm_min, t->tm_sec);
570 }
571
572 static void
573 fact_perm(const char *fact, FILE *fd, factelem *fe)
574 {
575         int             rok, wok, xok, pdirwok;
576         struct stat     *pdir;
577
578         if (fe->stat->st_uid == geteuid()) {
579                 rok = ((fe->stat->st_mode & S_IRUSR) != 0);
580                 wok = ((fe->stat->st_mode & S_IWUSR) != 0);
581                 xok = ((fe->stat->st_mode & S_IXUSR) != 0);
582         } else if (matchgroup(fe->stat->st_gid)) {
583                 rok = ((fe->stat->st_mode & S_IRGRP) != 0);
584                 wok = ((fe->stat->st_mode & S_IWGRP) != 0);
585                 xok = ((fe->stat->st_mode & S_IXGRP) != 0);
586         } else {
587                 rok = ((fe->stat->st_mode & S_IROTH) != 0);
588                 wok = ((fe->stat->st_mode & S_IWOTH) != 0);
589                 xok = ((fe->stat->st_mode & S_IXOTH) != 0);
590         }
591
592         cprintf(fd, "%s=", fact);
593
594                         /*
595                          * if parent info not provided, look it up, but
596                          * only if the current class has modify rights,
597                          * since we only need this info in such a case.
598                          */
599         pdir = fe->pdirstat;
600         if (pdir == NULL && CURCLASS_FLAGS_ISSET(modify)) {
601                 size_t          len;
602                 char            realdir[MAXPATHLEN], *p;
603                 struct stat     dir;
604
605                 len = strlcpy(realdir, fe->path, sizeof(realdir));
606                 if (len < sizeof(realdir) - 4) {
607                         if (S_ISDIR(fe->stat->st_mode))
608                                 strlcat(realdir, "/..", sizeof(realdir));
609                         else {
610                                         /* if has a /, move back to it */
611                                         /* otherwise use '..' */
612                                 if ((p = strrchr(realdir, '/')) != NULL) {
613                                         if (p == realdir)
614                                                 p++;
615                                         *p = '\0';
616                                 } else
617                                         strlcpy(realdir, "..", sizeof(realdir));
618                         }
619                         if (stat(realdir, &dir) == 0)
620                                 pdir = &dir;
621                 }
622         }
623         pdirwok = 0;
624         if (pdir != NULL) {
625                 if (pdir->st_uid == geteuid())
626                         pdirwok = ((pdir->st_mode & S_IWUSR) != 0);
627                 else if (matchgroup(pdir->st_gid))
628                         pdirwok = ((pdir->st_mode & S_IWGRP) != 0);
629                 else
630                         pdirwok = ((pdir->st_mode & S_IWOTH) != 0);
631         }
632
633                         /* 'a': can APPE to file */
634         if (wok && CURCLASS_FLAGS_ISSET(upload) && S_ISREG(fe->stat->st_mode))
635                 CPUTC('a', fd);
636
637                         /* 'c': can create or append to files in directory */
638         if (wok && CURCLASS_FLAGS_ISSET(modify) && S_ISDIR(fe->stat->st_mode))
639                 CPUTC('c', fd);
640
641                         /* 'd': can delete file or directory */
642         if (pdirwok && CURCLASS_FLAGS_ISSET(modify)) {
643                 int candel;
644
645                 candel = 1;
646                 if (S_ISDIR(fe->stat->st_mode)) {
647                         DIR *dirp;
648                         struct dirent *dp;
649
650                         if ((dirp = opendir(fe->display)) == NULL)
651                                 candel = 0;
652                         else {
653                                 while ((dp = readdir(dirp)) != NULL) {
654                                         if (ISDOTDIR(dp->d_name) ||
655                                             ISDOTDOTDIR(dp->d_name))
656                                                 continue;
657                                         candel = 0;
658                                         break;
659                                 }
660                                 closedir(dirp);
661                         }
662                 }
663                 if (candel)
664                         CPUTC('d', fd);
665         }
666
667                         /* 'e': can enter directory */
668         if (xok && S_ISDIR(fe->stat->st_mode))
669                 CPUTC('e', fd);
670
671                         /* 'f': can rename file or directory */
672         if (pdirwok && CURCLASS_FLAGS_ISSET(modify))
673                 CPUTC('f', fd);
674
675                         /* 'l': can list directory */
676         if (rok && xok && S_ISDIR(fe->stat->st_mode))
677                 CPUTC('l', fd);
678
679                         /* 'm': can create directory */
680         if (wok && CURCLASS_FLAGS_ISSET(modify) && S_ISDIR(fe->stat->st_mode))
681                 CPUTC('m', fd);
682
683                         /* 'p': can remove files in directory */
684         if (wok && CURCLASS_FLAGS_ISSET(modify) && S_ISDIR(fe->stat->st_mode))
685                 CPUTC('p', fd);
686
687                         /* 'r': can RETR file */
688         if (rok && S_ISREG(fe->stat->st_mode))
689                 CPUTC('r', fd);
690
691                         /* 'w': can STOR file */
692         if (wok && CURCLASS_FLAGS_ISSET(upload) && S_ISREG(fe->stat->st_mode))
693                 CPUTC('w', fd);
694
695         CPUTC(';', fd);
696 }
697
698 static void
699 fact_size(const char *fact, FILE *fd, factelem *fe)
700 {
701
702         if (S_ISREG(fe->stat->st_mode))
703                 cprintf(fd, "%s=" LLF ";", fact, (LLT)fe->stat->st_size);
704 }
705
706 static void
707 fact_type(const char *fact, FILE *fd, factelem *fe)
708 {
709
710         cprintf(fd, "%s=", fact);
711         switch (fe->stat->st_mode & S_IFMT) {
712         case S_IFDIR:
713                 if (fe->flags & FE_MLSD) {
714                         if ((fe->flags & FE_ISCURDIR) || ISDOTDIR(fe->display))
715                                 cprintf(fd, "cdir");
716                         else if (ISDOTDOTDIR(fe->display))
717                                 cprintf(fd, "pdir");
718                         else
719                                 cprintf(fd, "dir");
720                 } else {
721                         cprintf(fd, "dir");
722                 }
723                 break;
724         case S_IFREG:
725                 cprintf(fd, "file");
726                 break;
727         case S_IFIFO:
728                 cprintf(fd, "OS.unix=fifo");
729                 break;
730         case S_IFLNK:           /* XXX: probably a NO-OP with stat() */
731                 cprintf(fd, "OS.unix=slink");
732                 break;
733         case S_IFSOCK:
734                 cprintf(fd, "OS.unix=socket");
735                 break;
736         case S_IFBLK:
737         case S_IFCHR:
738                 cprintf(fd, "OS.unix=%s-%d/%d",
739                     S_ISBLK(fe->stat->st_mode) ? "blk" : "chr",
740                     major(fe->stat->st_rdev), minor(fe->stat->st_rdev));
741                 break;
742         default:
743                 cprintf(fd, "OS.unix=UNKNOWN(0%o)", fe->stat->st_mode & S_IFMT);
744                 break;
745         }
746         CPUTC(';', fd);
747 }
748
749 static void
750 fact_unique(const char *fact, FILE *fd, factelem *fe)
751 {
752         char obuf[(sizeof(dev_t) + sizeof(ino_t) + 2) * 4 / 3 + 2];
753         char tbuf[sizeof(dev_t) + sizeof(ino_t)];
754
755         memcpy(tbuf,
756             (char *)&(fe->stat->st_dev), sizeof(dev_t));
757         memcpy(tbuf + sizeof(dev_t),
758             (char *)&(fe->stat->st_ino), sizeof(ino_t));
759         base64_encode(tbuf, sizeof(dev_t) + sizeof(ino_t), obuf, 1);
760         cprintf(fd, "%s=%s;", fact, obuf);
761 }
762
763 static int
764 matchgroup(gid_t gid)
765 {
766         int     i;
767
768         for (i = 0; i < gidcount; i++)
769                 if (gid == gidlist[i])
770                         return(1);
771         return (0);
772 }
773
774 static void
775 mlsname(FILE *fp, factelem *fe)
776 {
777         char realfile[MAXPATHLEN];
778         int i, userf;
779
780         for (i = 0; i < FACTTABSIZE; i++) {
781                 if (facttab[i].enabled)
782                         (facttab[i].display)(facttab[i].name, fp, fe);
783         }
784         if ((fe->flags & FE_MLSD) &&
785             !(fe->flags & FE_ISCURDIR) && !ISDOTDIR(fe->display)) {
786                         /* if MLSD and not "." entry, display as-is */
787                 userf = 0;
788         } else {
789                         /* if MLST, or MLSD and "." entry, realpath(3) it */
790                 if (realpath(fe->display, realfile) != NULL)
791                         userf = 1;
792         }
793         cprintf(fp, " %s\r\n", userf ? realfile : fe->display);
794 }
795
796 static void
797 replydirname(const char *name, const char *message)
798 {
799         char *p, *ep;
800         char npath[MAXPATHLEN * 2];
801
802         p = npath;
803         ep = &npath[sizeof(npath) - 1];
804         while (*name) {
805                 if (*name == '"') {
806                         if (ep - p < 2)
807                                 break;
808                         *p++ = *name++;
809                         *p++ = '"';
810                 } else {
811                         if (ep - p < 1)
812                                 break;
813                         *p++ = *name++;
814                 }
815         }
816         *p = '\0';
817         reply(257, "\"%s\" %s", npath, message);
818 }