Merge branch 'master' of git://linux-nfs.org/nfs-utils
[nfs-utils.git] / utils / idmapd / idmapd.c
1 /*
2  *  idmapd.c
3  *
4  *  Userland daemon for idmap.
5  *
6  *  Copyright (c) 2002 The Regents of the University of Michigan.
7  *  All rights reserved.
8  *
9  *  Marius Aamodt Eriksen <marius@umich.edu>
10  *
11  *  Redistribution and use in source and binary forms, with or without
12  *  modification, are permitted provided that the following conditions
13  *  are met:
14  *
15  *  1. Redistributions of source code must retain the above copyright
16  *     notice, this list of conditions and the following disclaimer.
17  *  2. Redistributions in binary form must reproduce the above copyright
18  *     notice, this list of conditions and the following disclaimer in the
19  *     documentation and/or other materials provided with the distribution.
20  *  3. Neither the name of the University nor the names of its
21  *     contributors may be used to endorse or promote products derived
22  *     from this software without specific prior written permission.
23  *
24  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
25  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
26  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
27  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
31  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
32  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
33  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
34  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35  */
36
37 #include <sys/types.h>
38 #include <sys/time.h>
39 #include <sys/poll.h>
40 #include <sys/socket.h>
41 #include <sys/stat.h>
42 #include <time.h>
43
44 #include "nfs_idmap.h"
45
46 #include <err.h>
47 #include <errno.h>
48 #include <event.h>
49 #include <fcntl.h>
50 #include <dirent.h>
51 #include <unistd.h>
52 #include <netdb.h>
53 #include <signal.h>
54 #include <stdio.h>
55 #include <stdlib.h>
56 #include <string.h>
57 #include <stdarg.h>
58 #include <syslog.h>
59 #include <pwd.h>
60 #include <grp.h>
61 #include <limits.h>
62 #include <ctype.h>
63 #include <nfsidmap.h>
64
65 #ifdef HAVE_CONFIG_H
66 #include "config.h"
67 #endif /* HAVE_CONFIG_H */
68
69 #include "cfg.h"
70 #include "queue.h"
71 #include "nfslib.h"
72
73 #ifndef PIPEFS_DIR
74 #define PIPEFS_DIR  "/var/lib/nfs/rpc_pipefs/"
75 #endif
76
77 #ifndef NFSD_DIR
78 #define NFSD_DIR  "/proc/net/rpc"
79 #endif
80
81 #ifndef CLIENT_CACHE_TIMEOUT_FILE
82 #define CLIENT_CACHE_TIMEOUT_FILE "/proc/sys/fs/nfs/idmap_cache_timeout"
83 #endif
84
85 #ifndef NFS4NOBODY_USER
86 #define NFS4NOBODY_USER "nobody"
87 #endif
88
89 #ifndef NFS4NOBODY_GROUP
90 #define NFS4NOBODY_GROUP "nobody"
91 #endif
92
93 /* From Niels */
94 #define CONF_SAVE(w, f) do {                    \
95         char *p = f;                            \
96         if (p != NULL)                          \
97                 (w) = p;                        \
98 } while (0)
99
100 #define IC_IDNAME 0
101 #define IC_IDNAME_CHAN  NFSD_DIR "/nfs4.idtoname/channel"
102 #define IC_IDNAME_FLUSH NFSD_DIR "/nfs4.idtoname/flush"
103
104 #define IC_NAMEID 1
105 #define IC_NAMEID_CHAN  NFSD_DIR "/nfs4.nametoid/channel"
106 #define IC_NAMEID_FLUSH NFSD_DIR "/nfs4.nametoid/flush"
107
108 struct idmap_client {
109         short                      ic_which;
110         char                       ic_clid[30];
111         char                      *ic_id;
112         char                       ic_path[PATH_MAX];
113         int                        ic_fd;
114         int                        ic_dirfd;
115         int                        ic_scanned;
116         struct event               ic_event;
117         TAILQ_ENTRY(idmap_client)  ic_next;
118 };
119 static struct idmap_client nfsd_ic[2] = {
120 {IC_IDNAME, "Server", "", IC_IDNAME_CHAN, -1, -1, 0},
121 {IC_NAMEID, "Server", "", IC_NAMEID_CHAN, -1, -1, 0},
122 };
123
124 TAILQ_HEAD(idmap_clientq, idmap_client);
125
126 static void dirscancb(int, short, void *);
127 static void clntscancb(int, short, void *);
128 static void svrreopen(int, short, void *);
129 static int  nfsopen(struct idmap_client *);
130 static void nfscb(int, short, void *);
131 static void nfsdcb(int, short, void *);
132 static int  validateascii(char *, u_int32_t);
133 static int  addfield(char **, ssize_t *, char *);
134 static int  getfield(char **, char *, size_t);
135
136 static void imconv(struct idmap_client *, struct idmap_msg *);
137 static void idtonameres(struct idmap_msg *);
138 static void nametoidres(struct idmap_msg *);
139
140 static int nfsdopen();
141 static int nfsdopenone(struct idmap_client *);
142 static void nfsdreopen(void);
143
144 size_t  strlcat(char *, const char *, size_t);
145 size_t  strlcpy(char *, const char *, size_t);
146 ssize_t atomicio(ssize_t (*)(), int, void *, size_t);
147 void    mydaemon(int, int);
148 void    release_parent();
149
150 static int verbose = 0;
151 #define DEFAULT_IDMAP_CACHE_EXPIRY 600 /* seconds */
152 static int cache_entry_expiration = 0;
153 static char pipefsdir[PATH_MAX];
154 static char *nobodyuser, *nobodygroup;
155 static uid_t nobodyuid;
156 static gid_t nobodygid;
157
158 /* Used by cfg.c */
159 char *conf_path;
160
161 static int
162 flush_nfsd_cache(char *path, time_t now)
163 {
164         int fd;
165         char stime[20];
166
167         sprintf(stime, "%ld\n", now);
168         fd = open(path, O_RDWR);
169         if (fd == -1)
170                 return -1;
171         write(fd, stime, strlen(stime));
172         close(fd);
173         return 0;
174 }
175
176 static int
177 flush_nfsd_idmap_cache(void)
178 {
179         time_t now = time(NULL);
180         int ret;
181
182         ret = flush_nfsd_cache(IC_IDNAME_FLUSH, now);
183         if (ret)
184                 return ret;
185         ret = flush_nfsd_cache(IC_NAMEID_FLUSH, now);
186         return ret;
187 }
188
189 static void
190 msg_format(char *rtnbuff, int rtnbuffsize, int errval,
191            const char *fmt, va_list args)
192 {
193         char buff[1024];
194         int n;
195
196         vsnprintf(buff, sizeof(buff), fmt, args);
197
198         if ((n = strlen(buff)) > 0 && buff[n-1] == '\n')
199                 buff[--n] = '\0';
200
201         snprintf(rtnbuff, rtnbuffsize, "%s: %s", buff, strerror(errval));
202 }
203
204 static void
205 idmapd_warn(const char *fmt, ...)
206 {
207         int errval = errno;     /* save this! */
208         char buff[1024];
209         va_list args;
210
211         va_start(args, fmt);
212         msg_format(buff, sizeof(buff), errval, fmt, args);
213         va_end(args);
214
215         syslog(LOG_WARNING, "%s", buff);
216 }
217
218 static void
219 idmapd_warnx(const char *fmt, ...)
220 {
221         va_list args;
222
223         va_start(args, fmt);
224         vsyslog(LOG_WARNING, fmt, args);
225         va_end(args);
226 }
227
228 static void
229 idmapd_err(int eval, const char *fmt, ...)
230 {
231         int errval = errno;     /* save this! */
232         char buff[1024];
233         va_list args;
234
235         va_start(args, fmt);
236         msg_format(buff, sizeof(buff), errval, fmt, args);
237         va_end(args);
238
239         syslog(LOG_ERR, "%s", buff);
240         exit(eval);
241 }
242
243 static void
244 idmapd_errx(int eval, const char *fmt, ...)
245 {
246         va_list args;
247
248         va_start(args, fmt);
249         vsyslog(LOG_ERR, fmt, args);
250         va_end(args);
251         exit(eval);
252 }
253
254 int
255 main(int argc, char **argv)
256 {
257         int fd = 0, opt, fg = 0, nfsdret = -1;
258         struct idmap_clientq icq;
259         struct event rootdirev, clntdirev, svrdirev;
260         struct event initialize;
261         struct passwd *pw;
262         struct group *gr;
263         struct stat sb;
264         char *xpipefsdir = NULL;
265         int serverstart = 1, clientstart = 1;
266         int ret;
267         char *progname;
268
269         conf_path = _PATH_IDMAPDCONF;
270         nobodyuser = NFS4NOBODY_USER;
271         nobodygroup = NFS4NOBODY_GROUP;
272         strlcpy(pipefsdir, PIPEFS_DIR, sizeof(pipefsdir));
273
274         if ((progname = strrchr(argv[0], '/')))
275                 progname++;
276         else
277                 progname = argv[0];
278         openlog(progname, LOG_PID, LOG_DAEMON);
279
280 #define GETOPTSTR "vfd:p:U:G:c:CS"
281         opterr=0; /* Turn off error messages */
282         while ((opt = getopt(argc, argv, GETOPTSTR)) != -1) {
283                 if (opt == 'c')
284                         conf_path = optarg;
285                 if (opt == '?') {
286                         if (strchr(GETOPTSTR, optopt))
287                                 errx(1, "'-%c' option requires an argument.", optopt);
288                         else
289                                 errx(1, "'-%c' is an invalid argument.", optopt);
290                 }
291         }
292         optind = 1;
293
294         if (stat(conf_path, &sb) == -1 && (errno == ENOENT || errno == EACCES)) {
295                 warn("Skipping configuration file \"%s\"", conf_path);
296                 conf_path = NULL;
297         } else {
298                 conf_init();
299                 verbose = conf_get_num("General", "Verbosity", 0);
300                 cache_entry_expiration = conf_get_num("General",
301                                 "Cache-Expiration", DEFAULT_IDMAP_CACHE_EXPIRY);
302                 CONF_SAVE(xpipefsdir, conf_get_str("General", "Pipefs-Directory"));
303                 if (xpipefsdir != NULL)
304                         strlcpy(pipefsdir, xpipefsdir, sizeof(pipefsdir));
305                 CONF_SAVE(nobodyuser, conf_get_str("Mapping", "Nobody-User"));
306                 CONF_SAVE(nobodygroup, conf_get_str("Mapping", "Nobody-Group"));
307         }
308
309         while ((opt = getopt(argc, argv, GETOPTSTR)) != -1)
310                 switch (opt) {
311                 case 'v':
312                         verbose++;
313                         break;
314                 case 'f':
315                         fg = 1;
316                         break;
317                 case 'p':
318                         strlcpy(pipefsdir, optarg, sizeof(pipefsdir));
319                         break;
320                 case 'd':
321                 case 'U':
322                 case 'G':
323                         errx(1, "the -d, -U, and -G options have been removed;"
324                                 " please use the configuration file instead.");
325                 case 'C':
326                         serverstart = 0;
327                         break;
328                 case 'S':
329                         clientstart = 0;
330                         break;
331                 default:
332                         break;
333                 }
334
335         if (!serverstart && !clientstart)
336                 errx(1, "it is illegal to specify both -C and -S");
337
338         strncat(pipefsdir, "/nfs", sizeof(pipefsdir));
339
340         if ((pw = getpwnam(nobodyuser)) == NULL)
341                 errx(1, "Could not find user \"%s\"", nobodyuser);
342         nobodyuid = pw->pw_uid;
343
344         if ((gr = getgrnam(nobodygroup)) == NULL)
345                 errx(1, "Could not find group \"%s\"", nobodygroup);
346         nobodygid = gr->gr_gid;
347
348 #ifdef HAVE_NFS4_SET_DEBUG
349         nfs4_set_debug(verbose, idmapd_warnx);
350 #endif
351         if (conf_path == NULL)
352                 conf_path = _PATH_IDMAPDCONF;
353         if (nfs4_init_name_mapping(conf_path))
354                 errx(1, "Unable to create name to user id mappings.");
355
356         if (!fg)
357                 mydaemon(0, 0);
358
359         event_init();
360
361         if (verbose > 0)
362                 idmapd_warnx("Expiration time is %d seconds.",
363                              cache_entry_expiration);
364         if (serverstart) {
365                 nfsdret = nfsdopen();
366                 if (nfsdret == 0) {
367                         ret = flush_nfsd_idmap_cache();
368                         if (ret)
369                                 idmapd_errx(1,
370                                         "main: Failed to flush nfsd idmap cache\n");
371                 }
372         }
373
374         if (clientstart) {
375                 struct timeval now = {
376                         .tv_sec = 0,
377                         .tv_usec = 0,
378                 };
379
380                 if (cache_entry_expiration != DEFAULT_IDMAP_CACHE_EXPIRY) {
381                         int timeout_fd, len;
382                         char timeout_buf[12];
383                         if ((timeout_fd = open(CLIENT_CACHE_TIMEOUT_FILE,
384                                                O_RDWR)) == -1) {
385                                 idmapd_warnx("Unable to open '%s' to set "
386                                              "client cache expiration time "
387                                              "to %d seconds\n",
388                                              CLIENT_CACHE_TIMEOUT_FILE,
389                                              cache_entry_expiration);
390                         } else {
391                                 len = snprintf(timeout_buf, sizeof(timeout_buf),
392                                                "%d", cache_entry_expiration);
393                                 if ((write(timeout_fd, timeout_buf, len)) != len)
394                                         idmapd_warnx("Error writing '%s' to "
395                                                      "'%s' to set client "
396                                                      "cache expiration time\n",
397                                                      timeout_buf,
398                                                      CLIENT_CACHE_TIMEOUT_FILE);
399                                 close(timeout_fd);
400                         }
401                 }
402
403                 if ((fd = open(pipefsdir, O_RDONLY)) == -1)
404                         idmapd_err(1, "main: open(%s)", pipefsdir);
405
406                 if (fcntl(fd, F_SETSIG, SIGUSR1) == -1)
407                         idmapd_err(1, "main: fcntl(%s)", pipefsdir);
408
409                 if (fcntl(fd, F_NOTIFY,
410                         DN_CREATE | DN_DELETE | DN_MODIFY | DN_MULTISHOT) == -1)
411                         idmapd_err(1, "main: fcntl(%s)", pipefsdir);
412
413                 TAILQ_INIT(&icq);
414
415                 /* These events are persistent */
416                 signal_set(&rootdirev, SIGUSR1, dirscancb, &icq);
417                 signal_add(&rootdirev, NULL);
418                 signal_set(&clntdirev, SIGUSR2, clntscancb, &icq);
419                 signal_add(&clntdirev, NULL);
420                 signal_set(&svrdirev, SIGHUP, svrreopen, NULL);
421                 signal_add(&svrdirev, NULL);
422
423                 /* Fetch current state */
424                 /* (Delay till start of event_dispatch to avoid possibly losing
425                  * a SIGUSR1 between here and the call to event_dispatch().) */
426                 evtimer_set(&initialize, dirscancb, &icq);
427                 evtimer_add(&initialize, &now);
428         }
429
430         if (nfsdret != 0 && fd == 0)
431                 idmapd_errx(1, "main: Neither NFS client nor NFSd found");
432
433         release_parent();
434
435         if (event_dispatch() < 0)
436                 idmapd_errx(1, "main: event_dispatch returns errno %d (%s)",
437                             errno, strerror(errno));
438         /* NOTREACHED */
439         return 1;
440 }
441
442 static void
443 dirscancb(int fd, short which, void *data)
444 {
445         int nent, i;
446         struct dirent **ents;
447         struct idmap_client *ic;
448         char path[PATH_MAX];
449         struct idmap_clientq *icq = data;
450
451         nent = scandir(pipefsdir, &ents, NULL, alphasort);
452         if (nent == -1) {
453                 idmapd_warn("dirscancb: scandir(%s)", pipefsdir);
454                 return;
455         }
456
457         for (i = 0;  i < nent; i++) {
458                 if (ents[i]->d_reclen > 4 &&
459                     strncmp(ents[i]->d_name, "clnt", 4) == 0) {
460                         TAILQ_FOREACH(ic, icq, ic_next)
461                             if (strcmp(ents[i]->d_name + 4, ic->ic_clid) == 0)
462                                     break;
463                         if (ic != NULL)
464                                 goto next;
465
466                         if ((ic = calloc(1, sizeof(*ic))) == NULL)
467                                 return;
468                         strlcpy(ic->ic_clid, ents[i]->d_name + 4,
469                             sizeof(ic->ic_clid));
470                         path[0] = '\0';
471                         snprintf(path, sizeof(path), "%s/%s",
472                             pipefsdir, ents[i]->d_name);
473
474                         if ((ic->ic_dirfd = open(path, O_RDONLY, 0)) == -1) {
475                                 idmapd_warn("dirscancb: open(%s)", path);
476                                 free(ic);
477                                 return;
478                         }
479
480                         strlcat(path, "/idmap", sizeof(path));
481                         strlcpy(ic->ic_path, path, sizeof(ic->ic_path));
482
483                         if (verbose > 0)
484                                 idmapd_warnx("New client: %s", ic->ic_clid);
485
486                         if (nfsopen(ic) == -1) {
487                                 close(ic->ic_dirfd);
488                                 free(ic);
489                                 return;
490                         }
491
492                         ic->ic_id = "Client";
493
494                         TAILQ_INSERT_TAIL(icq, ic, ic_next);
495
496                 next:
497                         ic->ic_scanned = 1;
498                 }
499         }
500
501         TAILQ_FOREACH(ic, icq, ic_next) {
502                 if (!ic->ic_scanned) {
503                         event_del(&ic->ic_event);
504                         close(ic->ic_fd);
505                         close(ic->ic_dirfd);
506                         TAILQ_REMOVE(icq, ic, ic_next);
507                         if (verbose > 0) {
508                                 idmapd_warnx("Stale client: %s", ic->ic_clid);
509                                 idmapd_warnx("\t-> closed %s", ic->ic_path);
510                         }
511                         free(ic);
512                 } else
513                         ic->ic_scanned = 0;
514         }
515         return;
516 }
517
518 static void
519 svrreopen(int fd, short which, void *data)
520 {
521         nfsdreopen();
522 }
523
524 static void
525 clntscancb(int fd, short which, void *data)
526 {
527         struct idmap_clientq *icq = data;
528         struct idmap_client *ic;
529
530         TAILQ_FOREACH(ic, icq, ic_next)
531                 if (ic->ic_fd == -1 && nfsopen(ic) == -1) {
532                         close(ic->ic_dirfd);
533                         TAILQ_REMOVE(icq, ic, ic_next);
534                         free(ic);
535                 }
536 }
537
538 static void
539 nfsdcb(int fd, short which, void *data)
540 {
541         struct idmap_client *ic = data;
542         struct idmap_msg im;
543         u_char buf[IDMAP_MAXMSGSZ + 1];
544         size_t len;
545         ssize_t bsiz;
546         char *bp, typebuf[IDMAP_MAXMSGSZ],
547                 buf1[IDMAP_MAXMSGSZ], authbuf[IDMAP_MAXMSGSZ], *p;
548         unsigned long tmp;
549
550         if (which != EV_READ)
551                 goto out;
552
553         if ((len = read(ic->ic_fd, buf, sizeof(buf))) <= 0) {
554                 idmapd_warnx("nfsdcb: read(%s) failed: errno %d (%s)",
555                              ic->ic_path, len?errno:0, 
556                              len?strerror(errno):"End of File");
557                 goto out;
558         }
559
560         /* Get rid of newline and terminate buffer*/
561         buf[len - 1] = '\0';
562         bp = (char *)buf;
563
564         memset(&im, 0, sizeof(im));
565
566         /* Authentication name -- ignored for now*/
567         if (getfield(&bp, authbuf, sizeof(authbuf)) == -1) {
568                 idmapd_warnx("nfsdcb: bad authentication name in upcall\n");
569                 return;
570         }
571         if (getfield(&bp, typebuf, sizeof(typebuf)) == -1) {
572                 idmapd_warnx("nfsdcb: bad type in upcall\n");
573                 return;
574         }
575         if (verbose > 0)
576                 idmapd_warnx("nfsdcb: authbuf=%s authtype=%s",
577                              authbuf, typebuf);
578
579         im.im_type = strcmp(typebuf, "user") == 0 ?
580                 IDMAP_TYPE_USER : IDMAP_TYPE_GROUP;
581
582         switch (ic->ic_which) {
583         case IC_NAMEID:
584                 im.im_conv = IDMAP_CONV_NAMETOID;
585                 if (getfield(&bp, im.im_name, sizeof(im.im_name)) == -1) {
586                         idmapd_warnx("nfsdcb: bad name in upcall\n");
587                         return;
588                 }
589                 break;
590         case IC_IDNAME:
591                 im.im_conv = IDMAP_CONV_IDTONAME;
592                 if (getfield(&bp, buf1, sizeof(buf1)) == -1) {
593                         idmapd_warnx("nfsdcb: bad id in upcall\n");
594                         return;
595                 }
596                 tmp = strtoul(buf1, (char **)NULL, 10);
597                 im.im_id = (u_int32_t)tmp;
598                 if ((tmp == ULONG_MAX && errno == ERANGE)
599                                 || (unsigned long)im.im_id != tmp) {
600                         idmapd_warnx("nfsdcb: id '%s' too big!\n", buf1);
601                         return;
602                 }
603                 break;
604         default:
605                 idmapd_warnx("nfsdcb: Unknown which type %d", ic->ic_which);
606                 return;
607         }
608
609         imconv(ic, &im);
610
611         buf[0] = '\0';
612         bp = (char *)buf;
613         bsiz = sizeof(buf);
614
615         /* Authentication name */
616         addfield(&bp, &bsiz, authbuf);
617
618         switch (ic->ic_which) {
619         case IC_NAMEID:
620                 /* Type */
621                 p = im.im_type == IDMAP_TYPE_USER ? "user" : "group";
622                 addfield(&bp, &bsiz, p);
623                 /* Name */
624                 addfield(&bp, &bsiz, im.im_name);
625                 /* expiry */
626                 snprintf(buf1, sizeof(buf1), "%lu",
627                          time(NULL) + cache_entry_expiration);
628                 addfield(&bp, &bsiz, buf1);
629                 /* ID */
630                 snprintf(buf1, sizeof(buf1), "%u", im.im_id);
631                 addfield(&bp, &bsiz, buf1);
632
633                 //if (bsiz == sizeof(buf)) /* XXX */
634
635                 bp[-1] = '\n';
636
637                 break;
638         case IC_IDNAME:
639                 /* Type */
640                 p = im.im_type == IDMAP_TYPE_USER ? "user" : "group";
641                 addfield(&bp, &bsiz, p);
642                 /* ID */
643                 snprintf(buf1, sizeof(buf1), "%u", im.im_id);
644                 addfield(&bp, &bsiz, buf1);
645                 /* expiry */
646                 snprintf(buf1, sizeof(buf1), "%lu",
647                          time(NULL) + cache_entry_expiration);
648                 addfield(&bp, &bsiz, buf1);
649                 /* Name */
650                 addfield(&bp, &bsiz, im.im_name);
651
652                 bp[-1] = '\n';
653
654                 break;
655         default:
656                 idmapd_warnx("nfsdcb: Unknown which type %d", ic->ic_which);
657                 return;
658         }
659
660         bsiz = sizeof(buf) - bsiz;
661
662         if (atomicio(write, ic->ic_fd, buf, bsiz) != bsiz)
663                 idmapd_warnx("nfsdcb: write(%s) failed: errno %d (%s)",
664                              ic->ic_path, errno, strerror(errno));
665
666 out:
667         event_add(&ic->ic_event, NULL);
668 }
669
670 static void
671 imconv(struct idmap_client *ic, struct idmap_msg *im)
672 {
673         switch (im->im_conv) {
674         case IDMAP_CONV_IDTONAME:
675                 idtonameres(im);
676                 if (verbose > 1)
677                         idmapd_warnx("%s %s: (%s) id \"%d\" -> name \"%s\"",
678                             ic->ic_id, ic->ic_clid,
679                             im->im_type == IDMAP_TYPE_USER ? "user" : "group",
680                             im->im_id, im->im_name);
681                 break;
682         case IDMAP_CONV_NAMETOID:
683                 if (validateascii(im->im_name, sizeof(im->im_name)) == -1) {
684                         im->im_status |= IDMAP_STATUS_INVALIDMSG;
685                         return;
686                 }
687                 nametoidres(im);
688                 if (verbose > 1)
689                         idmapd_warnx("%s %s: (%s) name \"%s\" -> id \"%d\"",
690                             ic->ic_id, ic->ic_clid,
691                             im->im_type == IDMAP_TYPE_USER ? "user" : "group",
692                             im->im_name, im->im_id);
693                 break;
694         default:
695                 idmapd_warnx("imconv: Invalid conversion type (%d) in message",
696                              im->im_conv);
697                 im->im_status |= IDMAP_STATUS_INVALIDMSG;
698                 break;
699         }
700 }
701
702 static void
703 nfscb(int fd, short which, void *data)
704 {
705         struct idmap_client *ic = data;
706         struct idmap_msg im;
707
708         if (which != EV_READ)
709                 goto out;
710
711         if (atomicio(read, ic->ic_fd, &im, sizeof(im)) != sizeof(im)) {
712                 if (verbose > 0)
713                         idmapd_warn("nfscb: read(%s)", ic->ic_path);
714                 if (errno == EPIPE)
715                         return;
716                 goto out;
717         }
718
719         imconv(ic, &im);
720
721         if (atomicio(write, ic->ic_fd, &im, sizeof(im)) != sizeof(im))
722                 idmapd_warn("nfscb: write(%s)", ic->ic_path);
723 out:
724         event_add(&ic->ic_event, NULL);
725 }
726
727 static void
728 nfsdreopen_one(struct idmap_client *ic)
729 {
730         int fd;
731
732         if (verbose > 0)
733                 idmapd_warnx("ReOpening %s", ic->ic_path);
734
735         if ((fd = open(ic->ic_path, O_RDWR, 0)) != -1) {
736                 if ((ic->ic_event.ev_flags & EVLIST_INIT))
737                         event_del(&ic->ic_event);
738                 if (ic->ic_fd != -1)
739                         close(ic->ic_fd);
740
741                 ic->ic_event.ev_fd = ic->ic_fd = fd;
742                 event_set(&ic->ic_event, ic->ic_fd, EV_READ, nfsdcb, ic);
743                 event_add(&ic->ic_event, NULL);
744         } else {
745                 idmapd_warnx("nfsdreopen: Opening '%s' failed: errno %d (%s)",
746                         ic->ic_path, errno, strerror(errno));
747         }
748 }
749
750 static void
751 nfsdreopen()
752 {
753         nfsdreopen_one(&nfsd_ic[IC_NAMEID]);
754         nfsdreopen_one(&nfsd_ic[IC_IDNAME]);
755         return;
756 }
757
758 static int
759 nfsdopen()
760 {
761         return ((nfsdopenone(&nfsd_ic[IC_NAMEID]) == 0 &&
762                     nfsdopenone(&nfsd_ic[IC_IDNAME]) == 0) ? 0 : -1);
763 }
764
765 static int
766 nfsdopenone(struct idmap_client *ic)
767 {
768         if ((ic->ic_fd = open(ic->ic_path, O_RDWR, 0)) == -1) {
769                 if (verbose > 0)
770                         idmapd_warnx("nfsdopenone: Opening %s failed: "
771                                 "errno %d (%s)",
772                                 ic->ic_path, errno, strerror(errno));
773                 return (-1);
774         }
775
776         event_set(&ic->ic_event, ic->ic_fd, EV_READ, nfsdcb, ic);
777         event_add(&ic->ic_event, NULL);
778
779         if (verbose > 0)
780                 idmapd_warnx("Opened %s", ic->ic_path);
781
782         return (0);
783 }
784
785 static int
786 nfsopen(struct idmap_client *ic)
787 {
788         if ((ic->ic_fd = open(ic->ic_path, O_RDWR, 0)) == -1) {
789                 switch (errno) {
790                 case ENOENT:
791                         fcntl(ic->ic_dirfd, F_SETSIG, SIGUSR2);
792                         fcntl(ic->ic_dirfd, F_NOTIFY,
793                             DN_CREATE | DN_DELETE | DN_MULTISHOT);
794                         break;
795                 default:
796                         idmapd_warn("nfsopen: open(%s)", ic->ic_path);
797                         return (-1);
798                 }
799         } else {
800                 event_set(&ic->ic_event, ic->ic_fd, EV_READ, nfscb, ic);
801                 event_add(&ic->ic_event, NULL);
802                 fcntl(ic->ic_dirfd, F_SETSIG, 0);
803                 fcntl(ic->ic_dirfd, F_NOTIFY, 0);
804                 if (verbose > 0)
805                         idmapd_warnx("Opened %s", ic->ic_path);
806         }
807
808         return (0);
809 }
810
811 static void
812 idtonameres(struct idmap_msg *im)
813 {
814         char domain[NFS4_MAX_DOMAIN_LEN];
815         int ret = 0;
816
817         ret = nfs4_get_default_domain(NULL, domain, sizeof(domain));
818         switch (im->im_type) {
819         case IDMAP_TYPE_USER:
820                 ret = nfs4_uid_to_name(im->im_id, domain, im->im_name,
821                                 sizeof(im->im_name));
822                 if (ret) {
823                         if (strlen(nobodyuser) < sizeof(im->im_name))
824                                 strcpy(im->im_name, nobodyuser);
825                         else
826                                 strcpy(im->im_name, NFS4NOBODY_USER);
827                 }
828                 break;
829         case IDMAP_TYPE_GROUP:
830                 ret = nfs4_gid_to_name(im->im_id, domain, im->im_name,
831                                 sizeof(im->im_name));
832                 if (ret) {
833                         if (strlen(nobodygroup) < sizeof(im->im_name))
834                                 strcpy(im->im_name, nobodygroup);
835                         else
836                                 strcpy(im->im_name, NFS4NOBODY_GROUP);
837                 }
838                 break;
839         }
840         /* XXX Hack? */
841         im->im_status = IDMAP_STATUS_SUCCESS;
842 }
843
844 static void
845 nametoidres(struct idmap_msg *im)
846 {
847         uid_t uid;
848         gid_t gid;
849         int ret = 0;
850
851         /* XXX: nobody fallbacks shouldn't always happen:
852          *      server id -> name should be OK
853          *      client name -> id should be OK
854          * but not otherwise */
855         /* XXX: move nobody stuff to library calls
856          * (nfs4_get_nobody_user(domain), nfs4_get_nobody_group(domain)) */
857         /* XXX: should make this call higher up in the call chain (so we'd
858          * have a chance on looking up server/whatever. */
859         switch (im->im_type) {
860         case IDMAP_TYPE_USER:
861                 ret = nfs4_name_to_uid(im->im_name, &uid);
862                 im->im_id = (u_int32_t) uid;
863                 if (ret)
864                         im->im_id = nobodyuid;
865                 break;
866         case IDMAP_TYPE_GROUP:
867                 ret = nfs4_name_to_gid(im->im_name, &gid);
868                 im->im_id = (u_int32_t) gid;
869                 if (ret)
870                         im->im_id = nobodygid;
871                 break;
872         }
873         /* XXX? */
874         im->im_status = IDMAP_STATUS_SUCCESS;
875 }
876
877 static int
878 validateascii(char *string, u_int32_t len)
879 {
880         int i;
881
882         for (i = 0; i < len; i++) {
883                 if (string[i] == '\0')
884                         break;
885
886                 if (string[i] & 0x80)
887                         return (-1);
888         }
889
890         if (string[i] != '\0')
891                 return (-1);
892
893         return (i + 1);
894 }
895
896 static int
897 addfield(char **bpp, ssize_t *bsizp, char *fld)
898 {
899         char ch, *bp = *bpp;
900         ssize_t bsiz = *bsizp;
901
902         while ((ch = *fld++) != '\0' && bsiz > 0) {
903                 switch(ch) {
904                 case ' ':
905                 case '\t':
906                 case '\n':
907                 case '\\':
908                         if (bsiz >= 4) {
909                                 bp += snprintf(bp, bsiz, "\\%03o", ch);
910                                 bsiz -= 4;
911                         }
912                         break;
913                 default:
914                         *bp++ = ch;
915                         bsiz--;
916                         break;
917                 }
918         }
919
920         if (bsiz < 1 || ch != '\0')
921                 return (-1);
922
923         *bp++ = ' ';
924         bsiz--;
925
926         *bpp = bp;
927         *bsizp = bsiz;
928
929         return (0);
930 }
931
932 static int
933 getfield(char **bpp, char *fld, size_t fldsz)
934 {
935         char *bp;
936         u_int val, n;
937
938         while ((bp = strsep(bpp, " ")) != NULL && bp[0] == '\0')
939                 ;
940
941         if (bp == NULL || bp[0] == '\0' || bp[0] == '\n')
942                 return (-1);
943
944         while (*bp != '\0' && fldsz > 1) {
945                 if (*bp == '\\') {
946                         if ((n = sscanf(bp, "\\%03o", &val)) != 1)
947                                 return (-1);
948                         if (val > (char)-1)
949                                 return (-1);
950                         *fld++ = (char)val;
951                         bp += 4;
952                 } else {
953                         *fld++ = *bp;
954                         bp++;
955                 }
956                 fldsz--;
957         }
958
959         if (*bp != '\0')
960                 return (-1);
961         *fld = '\0';
962
963         return (0);
964 }
965 /*
966  * mydaemon creates a pipe between the partent and child
967  * process. The parent process will wait until the
968  * child dies or writes a '1' on the pipe signaling
969  * that it started successfully.
970  */
971 int pipefds[2] = { -1, -1};
972
973 void
974 mydaemon(int nochdir, int noclose)
975 {
976         int pid, status, tempfd;
977
978         if (pipe(pipefds) < 0)
979                 err(1, "mydaemon: pipe() failed: errno %d", errno);
980
981         if ((pid = fork ()) < 0)
982                 err(1, "mydaemon: fork() failed: errno %d", errno);
983
984         if (pid != 0) {
985                 /*
986                  * Parent. Wait for status from child.
987                  */
988                 close(pipefds[1]);
989                 if (read(pipefds[0], &status, 1) != 1)
990                         exit(1);
991                 exit (0);
992         }
993         /* Child.       */
994         close(pipefds[0]);
995         setsid ();
996         if (nochdir == 0) {
997                 if (chdir ("/") == -1)
998                         err(1, "mydaemon: chdir() failed: errno %d", errno);
999         }
1000
1001         while (pipefds[1] <= 2) {
1002                 pipefds[1] = dup(pipefds[1]);
1003                 if (pipefds[1] < 0)
1004                         err(1, "mydaemon: dup() failed: errno %d", errno);
1005         }
1006
1007         if (noclose == 0) {
1008                 tempfd = open("/dev/null", O_RDWR);
1009                 if (tempfd < 0)
1010                         tempfd = open("/", O_RDONLY);
1011                 if (tempfd >= 0) {
1012                         dup2(tempfd, 0);
1013                         dup2(tempfd, 1);
1014                         dup2(tempfd, 2);
1015                         closeall(3);
1016                 } else
1017                         closeall(0);
1018         }
1019
1020         return;
1021 }
1022 void
1023 release_parent()
1024 {
1025         int status;
1026
1027         if (pipefds[1] > 0) {
1028                 write(pipefds[1], &status, 1);
1029                 close(pipefds[1]);
1030                 pipefds[1] = -1;
1031         }
1032 }