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 }