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