4 * Userland daemon for idmap.
6 * Copyright (c) 2002 The Regents of the University of Michigan.
9 * Marius Aamodt Eriksen <marius@umich.edu>
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
37 #include <sys/types.h>
40 #include <sys/socket.h>
44 #include "nfs_idmap.h"
66 #endif /* HAVE_CONFIG_H */
74 #define PIPEFS_DIR "/var/lib/nfs/rpc_pipefs/"
78 #define NFSD_DIR "/proc/net/rpc"
81 #ifndef CLIENT_CACHE_TIMEOUT_FILE
82 #define CLIENT_CACHE_TIMEOUT_FILE "/proc/sys/fs/nfs/idmap_cache_timeout"
85 #ifndef NFS4NOBODY_USER
86 #define NFS4NOBODY_USER "nobody"
89 #ifndef NFS4NOBODY_GROUP
90 #define NFS4NOBODY_GROUP "nobody"
94 #define CONF_SAVE(w, f) do { \
101 #define IC_IDNAME_CHAN NFSD_DIR "/nfs4.idtoname/channel"
102 #define IC_IDNAME_FLUSH NFSD_DIR "/nfs4.idtoname/flush"
105 #define IC_NAMEID_CHAN NFSD_DIR "/nfs4.nametoid/channel"
106 #define IC_NAMEID_FLUSH NFSD_DIR "/nfs4.nametoid/flush"
108 struct idmap_client {
112 char ic_path[PATH_MAX];
116 struct event ic_event;
117 TAILQ_ENTRY(idmap_client) ic_next;
119 static struct idmap_client nfsd_ic[2] = {
121 .ic_which = IC_IDNAME,
124 .ic_path = IC_IDNAME_CHAN,
130 .ic_which = IC_NAMEID,
133 .ic_path = IC_NAMEID_CHAN,
140 TAILQ_HEAD(idmap_clientq, idmap_client);
142 static void dirscancb(int, short, void *);
143 static void clntscancb(int, short, void *);
144 static void svrreopen(int, short, void *);
145 static int nfsopen(struct idmap_client *);
146 static void nfscb(int, short, void *);
147 static void nfsdcb(int, short, void *);
148 static int validateascii(char *, u_int32_t);
149 static int addfield(char **, ssize_t *, char *);
150 static int getfield(char **, char *, size_t);
152 static void imconv(struct idmap_client *, struct idmap_msg *);
153 static void idtonameres(struct idmap_msg *);
154 static void nametoidres(struct idmap_msg *);
156 static int nfsdopen(void);
157 static int nfsdopenone(struct idmap_client *);
158 static void nfsdreopen_one(struct idmap_client *);
159 static void nfsdreopen(void);
161 size_t strlcat(char *, const char *, size_t);
162 size_t strlcpy(char *, const char *, size_t);
163 ssize_t atomicio(ssize_t (*f) (int, void*, size_t),
164 int, void *, size_t);
165 void mydaemon(int, int);
166 void release_parent(void);
168 static int verbose = 0;
169 #define DEFAULT_IDMAP_CACHE_EXPIRY 600 /* seconds */
170 static int cache_entry_expiration = 0;
171 static char pipefsdir[PATH_MAX];
172 static char *nobodyuser, *nobodygroup;
173 static uid_t nobodyuid;
174 static gid_t nobodygid;
176 /* Used by conffile.c in libnfs.a */
180 flush_nfsd_cache(char *path, time_t now)
185 sprintf(stime, "%ld\n", now);
186 fd = open(path, O_RDWR);
189 if (write(fd, stime, strlen(stime)) != (ssize_t)strlen(stime)) {
190 errx(1, "Flushing nfsd cache failed: errno %d (%s)",
191 errno, strerror(errno));
198 flush_nfsd_idmap_cache(void)
200 time_t now = time(NULL);
203 ret = flush_nfsd_cache(IC_IDNAME_FLUSH, now);
206 ret = flush_nfsd_cache(IC_NAMEID_FLUSH, now);
211 main(int argc, char **argv)
213 int fd = 0, opt, fg = 0, nfsdret = -1;
214 struct idmap_clientq icq;
215 struct event rootdirev, clntdirev, svrdirev;
216 struct event initialize;
220 char *xpipefsdir = NULL;
221 int serverstart = 1, clientstart = 1;
225 conf_path = _PATH_IDMAPDCONF;
226 nobodyuser = NFS4NOBODY_USER;
227 nobodygroup = NFS4NOBODY_GROUP;
228 strlcpy(pipefsdir, PIPEFS_DIR, sizeof(pipefsdir));
230 if ((progname = strrchr(argv[0], '/')))
236 #define GETOPTSTR "vfd:p:U:G:c:CS"
237 opterr=0; /* Turn off error messages */
238 while ((opt = getopt(argc, argv, GETOPTSTR)) != -1) {
242 if (strchr(GETOPTSTR, optopt))
243 errx(1, "'-%c' option requires an argument.", optopt);
245 errx(1, "'-%c' is an invalid argument.", optopt);
250 if (stat(conf_path, &sb) == -1 && (errno == ENOENT || errno == EACCES)) {
251 warn("Skipping configuration file \"%s\"", conf_path);
255 verbose = conf_get_num("General", "Verbosity", 0);
256 cache_entry_expiration = conf_get_num("General",
257 "Cache-Expiration", DEFAULT_IDMAP_CACHE_EXPIRY);
258 CONF_SAVE(xpipefsdir, conf_get_str("General", "Pipefs-Directory"));
259 if (xpipefsdir != NULL)
260 strlcpy(pipefsdir, xpipefsdir, sizeof(pipefsdir));
261 CONF_SAVE(nobodyuser, conf_get_str("Mapping", "Nobody-User"));
262 CONF_SAVE(nobodygroup, conf_get_str("Mapping", "Nobody-Group"));
265 while ((opt = getopt(argc, argv, GETOPTSTR)) != -1)
274 strlcpy(pipefsdir, optarg, sizeof(pipefsdir));
279 errx(1, "the -d, -U, and -G options have been removed;"
280 " please use the configuration file instead.");
291 if (!serverstart && !clientstart)
292 errx(1, "it is illegal to specify both -C and -S");
294 strncat(pipefsdir, "/nfs", sizeof(pipefsdir));
296 if ((pw = getpwnam(nobodyuser)) == NULL)
297 errx(1, "Could not find user \"%s\"", nobodyuser);
298 nobodyuid = pw->pw_uid;
300 if ((gr = getgrnam(nobodygroup)) == NULL)
301 errx(1, "Could not find group \"%s\"", nobodygroup);
302 nobodygid = gr->gr_gid;
304 #ifdef HAVE_NFS4_SET_DEBUG
305 nfs4_set_debug(verbose, xlog_warn);
307 if (conf_path == NULL)
308 conf_path = _PATH_IDMAPDCONF;
309 if (nfs4_init_name_mapping(conf_path))
310 errx(1, "Unable to create name to user id mappings.");
318 xlog_warn("Expiration time is %d seconds.",
319 cache_entry_expiration);
321 nfsdret = nfsdopen();
323 ret = flush_nfsd_idmap_cache();
325 xlog_err("main: Failed to flush nfsd idmap cache\n: %s", strerror(errno));
330 struct timeval now = {
335 if (cache_entry_expiration != DEFAULT_IDMAP_CACHE_EXPIRY) {
337 char timeout_buf[12];
338 if ((timeout_fd = open(CLIENT_CACHE_TIMEOUT_FILE,
340 xlog_warn("Unable to open '%s' to set "
341 "client cache expiration time "
343 CLIENT_CACHE_TIMEOUT_FILE,
344 cache_entry_expiration);
346 len = snprintf(timeout_buf, sizeof(timeout_buf),
347 "%d", cache_entry_expiration);
348 if ((write(timeout_fd, timeout_buf, len)) != len)
349 xlog_warn("Error writing '%s' to "
350 "'%s' to set client "
351 "cache expiration time\n",
353 CLIENT_CACHE_TIMEOUT_FILE);
358 if ((fd = open(pipefsdir, O_RDONLY)) == -1)
359 xlog_err("main: open(%s): %s", pipefsdir, strerror(errno));
361 if (fcntl(fd, F_SETSIG, SIGUSR1) == -1)
362 xlog_err("main: fcntl(%s): %s", pipefsdir, strerror(errno));
364 if (fcntl(fd, F_NOTIFY,
365 DN_CREATE | DN_DELETE | DN_MODIFY | DN_MULTISHOT) == -1) {
366 xlog_err("main: fcntl(%s): %s", pipefsdir, strerror(errno));
368 xlog_err("main: Possibly no Dnotify support in kernel.");
372 /* These events are persistent */
373 signal_set(&rootdirev, SIGUSR1, dirscancb, &icq);
374 signal_add(&rootdirev, NULL);
375 signal_set(&clntdirev, SIGUSR2, clntscancb, &icq);
376 signal_add(&clntdirev, NULL);
377 signal_set(&svrdirev, SIGHUP, svrreopen, NULL);
378 signal_add(&svrdirev, NULL);
380 /* Fetch current state */
381 /* (Delay till start of event_dispatch to avoid possibly losing
382 * a SIGUSR1 between here and the call to event_dispatch().) */
383 evtimer_set(&initialize, dirscancb, &icq);
384 evtimer_add(&initialize, &now);
387 if (nfsdret != 0 && fd == 0)
388 xlog_err("main: Neither NFS client nor NFSd found");
392 if (event_dispatch() < 0)
393 xlog_err("main: event_dispatch returns errno %d (%s)",
394 errno, strerror(errno));
400 dirscancb(int UNUSED(fd), short UNUSED(which), void *data)
403 struct dirent **ents;
404 struct idmap_client *ic, *nextic;
406 struct idmap_clientq *icq = data;
408 nent = scandir(pipefsdir, &ents, NULL, alphasort);
410 xlog_warn("dirscancb: scandir(%s): %s", pipefsdir, strerror(errno));
414 for (i = 0; i < nent; i++) {
415 if (ents[i]->d_reclen > 4 &&
416 strncmp(ents[i]->d_name, "clnt", 4) == 0) {
417 TAILQ_FOREACH(ic, icq, ic_next)
418 if (strcmp(ents[i]->d_name + 4, ic->ic_clid) == 0)
423 if ((ic = calloc(1, sizeof(*ic))) == NULL)
425 strlcpy(ic->ic_clid, ents[i]->d_name + 4,
426 sizeof(ic->ic_clid));
428 snprintf(path, sizeof(path), "%s/%s",
429 pipefsdir, ents[i]->d_name);
431 if ((ic->ic_dirfd = open(path, O_RDONLY, 0)) == -1) {
432 xlog_warn("dirscancb: open(%s): %s", path, strerror(errno));
437 strlcat(path, "/idmap", sizeof(path));
438 strlcpy(ic->ic_path, path, sizeof(ic->ic_path));
441 xlog_warn("New client: %s", ic->ic_clid);
443 if (nfsopen(ic) == -1) {
449 ic->ic_id = "Client";
451 TAILQ_INSERT_TAIL(icq, ic, ic_next);
458 ic = TAILQ_FIRST(icq);
460 nextic=TAILQ_NEXT(ic, ic_next);
461 if (!ic->ic_scanned) {
462 event_del(&ic->ic_event);
465 TAILQ_REMOVE(icq, ic, ic_next);
467 xlog_warn("Stale client: %s", ic->ic_clid);
468 xlog_warn("\t-> closed %s", ic->ic_path);
477 for (i = 0; i < nent; i++)
484 svrreopen(int UNUSED(fd), short UNUSED(which), void *UNUSED(data))
490 clntscancb(int UNUSED(fd), short UNUSED(which), void *data)
492 struct idmap_clientq *icq = data;
493 struct idmap_client *ic;
495 TAILQ_FOREACH(ic, icq, ic_next)
496 if (ic->ic_fd == -1 && nfsopen(ic) == -1) {
498 TAILQ_REMOVE(icq, ic, ic_next);
504 nfsdcb(int UNUSED(fd), short which, void *data)
506 struct idmap_client *ic = data;
508 u_char buf[IDMAP_MAXMSGSZ + 1];
511 char *bp, typebuf[IDMAP_MAXMSGSZ],
512 buf1[IDMAP_MAXMSGSZ], authbuf[IDMAP_MAXMSGSZ], *p;
515 if (which != EV_READ)
518 if ((len = read(ic->ic_fd, buf, sizeof(buf))) <= 0) {
519 xlog_warn("nfsdcb: read(%s) failed: errno %d (%s)",
520 ic->ic_path, len?errno:0,
521 len?strerror(errno):"End of File");
526 /* Get rid of newline and terminate buffer*/
530 memset(&im, 0, sizeof(im));
532 /* Authentication name -- ignored for now*/
533 if (getfield(&bp, authbuf, sizeof(authbuf)) == -1) {
534 xlog_warn("nfsdcb: bad authentication name in upcall\n");
537 if (getfield(&bp, typebuf, sizeof(typebuf)) == -1) {
538 xlog_warn("nfsdcb: bad type in upcall\n");
542 xlog_warn("nfsdcb: authbuf=%s authtype=%s",
545 im.im_type = strcmp(typebuf, "user") == 0 ?
546 IDMAP_TYPE_USER : IDMAP_TYPE_GROUP;
548 switch (ic->ic_which) {
550 im.im_conv = IDMAP_CONV_NAMETOID;
551 if (getfield(&bp, im.im_name, sizeof(im.im_name)) == -1) {
552 xlog_warn("nfsdcb: bad name in upcall\n");
557 im.im_conv = IDMAP_CONV_IDTONAME;
558 if (getfield(&bp, buf1, sizeof(buf1)) == -1) {
559 xlog_warn("nfsdcb: bad id in upcall\n");
562 tmp = strtoul(buf1, (char **)NULL, 10);
563 im.im_id = (u_int32_t)tmp;
564 if ((tmp == ULONG_MAX && errno == ERANGE)
565 || (unsigned long)im.im_id != tmp) {
566 xlog_warn("nfsdcb: id '%s' too big!\n", buf1);
571 xlog_warn("nfsdcb: Unknown which type %d", ic->ic_which);
581 /* Authentication name */
582 addfield(&bp, &bsiz, authbuf);
584 switch (ic->ic_which) {
587 p = im.im_type == IDMAP_TYPE_USER ? "user" : "group";
588 addfield(&bp, &bsiz, p);
590 addfield(&bp, &bsiz, im.im_name);
592 snprintf(buf1, sizeof(buf1), "%lu",
593 time(NULL) + cache_entry_expiration);
594 addfield(&bp, &bsiz, buf1);
595 /* Note that we don't want to write the id if the mapping
596 * failed; instead, by leaving it off, we write a negative
597 * cache entry which will result in an error returned to
598 * the client. We don't want a chown or setacl referring
599 * to an unknown user to result in giving permissions to
601 if (im.im_status == IDMAP_STATUS_SUCCESS) {
603 snprintf(buf1, sizeof(buf1), "%u", im.im_id);
604 addfield(&bp, &bsiz, buf1);
607 //if (bsiz == sizeof(buf)) /* XXX */
614 p = im.im_type == IDMAP_TYPE_USER ? "user" : "group";
615 addfield(&bp, &bsiz, p);
617 snprintf(buf1, sizeof(buf1), "%u", im.im_id);
618 addfield(&bp, &bsiz, buf1);
620 snprintf(buf1, sizeof(buf1), "%lu",
621 time(NULL) + cache_entry_expiration);
622 addfield(&bp, &bsiz, buf1);
623 /* Note we're ignoring the status field in this case; we'll
624 * just map to nobody instead. */
626 addfield(&bp, &bsiz, im.im_name);
632 xlog_warn("nfsdcb: Unknown which type %d", ic->ic_which);
636 bsiz = sizeof(buf) - bsiz;
638 if (atomicio((void*)write, ic->ic_fd, buf, bsiz) != bsiz)
639 xlog_warn("nfsdcb: write(%s) failed: errno %d (%s)",
640 ic->ic_path, errno, strerror(errno));
643 event_add(&ic->ic_event, NULL);
647 imconv(struct idmap_client *ic, struct idmap_msg *im)
649 switch (im->im_conv) {
650 case IDMAP_CONV_IDTONAME:
653 xlog_warn("%s %s: (%s) id \"%d\" -> name \"%s\"",
654 ic->ic_id, ic->ic_clid,
655 im->im_type == IDMAP_TYPE_USER ? "user" : "group",
656 im->im_id, im->im_name);
658 case IDMAP_CONV_NAMETOID:
659 if (validateascii(im->im_name, sizeof(im->im_name)) == -1) {
660 im->im_status |= IDMAP_STATUS_INVALIDMSG;
665 xlog_warn("%s %s: (%s) name \"%s\" -> id \"%d\"",
666 ic->ic_id, ic->ic_clid,
667 im->im_type == IDMAP_TYPE_USER ? "user" : "group",
668 im->im_name, im->im_id);
671 xlog_warn("imconv: Invalid conversion type (%d) in message",
673 im->im_status |= IDMAP_STATUS_INVALIDMSG;
679 nfscb(int UNUSED(fd), short which, void *data)
681 struct idmap_client *ic = data;
684 if (which != EV_READ)
687 if (atomicio(read, ic->ic_fd, &im, sizeof(im)) != sizeof(im)) {
689 xlog_warn("nfscb: read(%s): %s", ic->ic_path, strerror(errno));
697 /* XXX: I don't like ignoring this error in the id->name case,
698 * but we've never returned it, and I need to check that the client
699 * can handle it gracefully before starting to return it now. */
701 if (im.im_status == IDMAP_STATUS_LOOKUPFAIL)
702 im.im_status = IDMAP_STATUS_SUCCESS;
704 if (atomicio((void*)write, ic->ic_fd, &im, sizeof(im)) != sizeof(im))
705 xlog_warn("nfscb: write(%s): %s", ic->ic_path, strerror(errno));
707 event_add(&ic->ic_event, NULL);
711 nfsdreopen_one(struct idmap_client *ic)
716 xlog_warn("ReOpening %s", ic->ic_path);
718 if ((fd = open(ic->ic_path, O_RDWR, 0)) != -1) {
719 if ((ic->ic_event.ev_flags & EVLIST_INIT))
720 event_del(&ic->ic_event);
724 ic->ic_event.ev_fd = ic->ic_fd = fd;
725 event_set(&ic->ic_event, ic->ic_fd, EV_READ, nfsdcb, ic);
726 event_add(&ic->ic_event, NULL);
728 xlog_warn("nfsdreopen: Opening '%s' failed: errno %d (%s)",
729 ic->ic_path, errno, strerror(errno));
736 nfsdreopen_one(&nfsd_ic[IC_NAMEID]);
737 nfsdreopen_one(&nfsd_ic[IC_IDNAME]);
744 return ((nfsdopenone(&nfsd_ic[IC_NAMEID]) == 0 &&
745 nfsdopenone(&nfsd_ic[IC_IDNAME]) == 0) ? 0 : -1);
749 nfsdopenone(struct idmap_client *ic)
751 if ((ic->ic_fd = open(ic->ic_path, O_RDWR, 0)) == -1) {
753 xlog_warn("nfsdopenone: Opening %s failed: "
755 ic->ic_path, errno, strerror(errno));
759 event_set(&ic->ic_event, ic->ic_fd, EV_READ, nfsdcb, ic);
760 event_add(&ic->ic_event, NULL);
763 xlog_warn("Opened %s", ic->ic_path);
769 nfsopen(struct idmap_client *ic)
771 if ((ic->ic_fd = open(ic->ic_path, O_RDWR, 0)) == -1) {
774 fcntl(ic->ic_dirfd, F_SETSIG, SIGUSR2);
775 fcntl(ic->ic_dirfd, F_NOTIFY,
776 DN_CREATE | DN_DELETE | DN_MULTISHOT);
779 xlog_warn("nfsopen: open(%s): %s", ic->ic_path, strerror(errno));
783 event_set(&ic->ic_event, ic->ic_fd, EV_READ, nfscb, ic);
784 event_add(&ic->ic_event, NULL);
785 fcntl(ic->ic_dirfd, F_SETSIG, 0);
786 fcntl(ic->ic_dirfd, F_NOTIFY, 0);
788 xlog_warn("Opened %s", ic->ic_path);
795 idtonameres(struct idmap_msg *im)
797 char domain[NFS4_MAX_DOMAIN_LEN];
800 ret = nfs4_get_default_domain(NULL, domain, sizeof(domain));
801 switch (im->im_type) {
802 case IDMAP_TYPE_USER:
803 ret = nfs4_uid_to_name(im->im_id, domain, im->im_name,
804 sizeof(im->im_name));
806 if (strlen(nobodyuser) < sizeof(im->im_name))
807 strcpy(im->im_name, nobodyuser);
809 strcpy(im->im_name, NFS4NOBODY_USER);
812 case IDMAP_TYPE_GROUP:
813 ret = nfs4_gid_to_name(im->im_id, domain, im->im_name,
814 sizeof(im->im_name));
816 if (strlen(nobodygroup) < sizeof(im->im_name))
817 strcpy(im->im_name, nobodygroup);
819 strcpy(im->im_name, NFS4NOBODY_GROUP);
824 im->im_status = IDMAP_STATUS_LOOKUPFAIL;
826 im->im_status = IDMAP_STATUS_SUCCESS;
830 nametoidres(struct idmap_msg *im)
836 /* XXX: move nobody stuff to library calls
837 * (nfs4_get_nobody_user(domain), nfs4_get_nobody_group(domain)) */
839 im->im_status = IDMAP_STATUS_SUCCESS;
841 switch (im->im_type) {
842 case IDMAP_TYPE_USER:
843 ret = nfs4_name_to_uid(im->im_name, &uid);
844 im->im_id = (u_int32_t) uid;
846 im->im_status = IDMAP_STATUS_LOOKUPFAIL;
847 im->im_id = nobodyuid;
850 case IDMAP_TYPE_GROUP:
851 ret = nfs4_name_to_gid(im->im_name, &gid);
852 im->im_id = (u_int32_t) gid;
854 im->im_status = IDMAP_STATUS_LOOKUPFAIL;
855 im->im_id = nobodygid;
862 validateascii(char *string, u_int32_t len)
866 for (i = 0; i < len; i++) {
867 if (string[i] == '\0')
870 if (string[i] & 0x80)
874 if ((i >= len) || string[i] != '\0')
881 addfield(char **bpp, ssize_t *bsizp, char *fld)
884 ssize_t bsiz = *bsizp;
886 while ((ch = *fld++) != '\0' && bsiz > 0) {
893 bp += snprintf(bp, bsiz, "\\%03o", ch);
904 if (bsiz < 1 || ch != '\0')
917 getfield(char **bpp, char *fld, size_t fldsz)
922 while ((bp = strsep(bpp, " ")) != NULL && bp[0] == '\0')
925 if (bp == NULL || bp[0] == '\0' || bp[0] == '\n')
928 while (*bp != '\0' && fldsz > 1) {
930 if ((n = sscanf(bp, "\\%03o", &val)) != 1)
950 * mydaemon creates a pipe between the partent and child
951 * process. The parent process will wait until the
952 * child dies or writes a '1' on the pipe signaling
953 * that it started successfully.
955 int pipefds[2] = { -1, -1};
958 mydaemon(int nochdir, int noclose)
960 int pid, status, tempfd;
962 if (pipe(pipefds) < 0)
963 err(1, "mydaemon: pipe() failed: errno %d", errno);
965 if ((pid = fork ()) < 0)
966 err(1, "mydaemon: fork() failed: errno %d", errno);
970 * Parent. Wait for status from child.
973 if (read(pipefds[0], &status, 1) != 1)
981 if (chdir ("/") == -1)
982 err(1, "mydaemon: chdir() failed: errno %d", errno);
985 while (pipefds[1] <= 2) {
986 pipefds[1] = dup(pipefds[1]);
988 err(1, "mydaemon: dup() failed: errno %d", errno);
992 tempfd = open("/dev/null", O_RDWR);
994 tempfd = open("/", O_RDONLY);
1001 err(1, "mydaemon: can't open /dev/null: errno %d",
1010 release_parent(void)
1014 if (pipefds[1] > 0) {
1015 if (write(pipefds[1], &status, 1) != 1) {
1016 err(1, "Writing to parent pipe failed: errno %d (%s)\n",
1017 errno, strerror(errno));