#gr_utils.c has to be deleted as soon as it goes in base

		usergroup.c \

HAVE_GRUTILS!=	grep -q gr_copy /usr/include/libutil.h && echo yes || echo no

.if ${HAVE_GRUTILS} != yes

SRCS+=	gr_util.c

.else

CFLAGS+=	-DHAVE_GRUTILS

.endif

static int 

#include <sys/param.h>

#include <sys/errno.h>

#include <sys/stat.h>

#include <ctype.h>

#include <err.h>

#include <fcntl.h>

#include <grp.h>

#include <inttypes.h>

#include <libutil.h>

#include <paths.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include "private/gr_util.h"

static int lockfd = -1;

static char group_dir[PATH_MAX];

static char group_file[PATH_MAX];

static char tempname[PATH_MAX];

static int initialized;

int

gr_init(const char *dir, const char *group)

{

	if (dir == NULL) {

		strcpy(group_dir, _PATH_ETC);

	} else {

		if (strlen(dir) >= sizeof(group_dir)) {

			errno = ENAMETOOLONG;

			return (-1);

		}

		strcpy(group_dir, dir);

	}

	if (group == NULL) {

		if (dir == NULL) {

			strcpy(group_file, _PATH_GROUP);

		} else if (snprintf(group_file, sizeof(group_file), "%s/group",

			group_dir) > (int)sizeof(group_file)) {

			errno = ENAMETOOLONG;

			return (-1);

		}

	} else {

		if (strlen(group) >= sizeof(group_file)) {

			errno = ENAMETOOLONG;

			return (-1);

		}

		strcpy(group_file, group);

	}

	initialized = 1;

	return (0);

}

/*

 * Lock the group file

 */

int

gr_lock(void)

{

	if (*group_file == '\0')

		return (-1);

	for (;;) {

		struct stat st;

		lockfd = open(group_file, O_RDONLY, 0);

		if (lockfd < 0 || fcntl(lockfd, F_SETFD, 1) == -1)

			err(1, "%s", group_file);

		if (flock(lockfd, LOCK_EX|LOCK_NB) == -1) {

			if (errno == EWOULDBLOCK) {

				errx(1, "the group file is busy");

			} else {

				err(1, "could not lock the group file: ");

			}

		}

		if (fstat(lockfd, &st) == -1)

			err(1, "fstat() failed: ");

		if (st.st_nlink != 0)

			break;

		close(lockfd);

		lockfd = -1;

	}

	return (lockfd);

}

/*

 * Create and open a presmuably safe temp file for editing group data

 */

int

gr_tmp(int mfd)

{

	char buf[8192];

	ssize_t nr;

	const char *p;

	int tfd;

	if (*group_file == '\0')

		return (-1);

	if ((p = strrchr(group_file, '/')))

		++p;

	else

		p = group_file;

	if (snprintf(tempname, sizeof(tempname), "%.*sgroup.XXXXXX",

		(int)(p - group_file), group_file) >= (int)sizeof(tempname)) {

		errno = ENAMETOOLONG;

		return (-1);

	}

	if ((tfd = mkstemp(tempname)) == -1)

		return (-1);

	if (mfd != -1) {

		while ((nr = read(mfd, buf, sizeof(buf))) > 0)

			if (write(tfd, buf, (size_t)nr) != nr)

				break;

		if (nr != 0) {

			unlink(tempname);

			*tempname = '\0';

			close(tfd);

			return (-1);

		}

	}

	return (tfd);

}

/*

 * Copy the group file from one descriptor to another, replacing, deleting

 * or adding a single record on the way.

 */

int

gr_copy(int ffd, int tfd, const struct group *gr, struct group *old_gr)

{

	char buf[8192], *end, *line, *p, *q, *r, t;

	struct group *fgr;

	const struct group *sgr;

	size_t len;

	int eof, readlen;

	sgr = gr;

	if (gr == NULL) {

		line = NULL;

		if (old_gr == NULL)

			return (-1);

		sgr = old_gr;

	} else if ((line = gr_make(gr)) == NULL)

		return (-1);

	eof = 0;

	len = 0;

	p = q = end = buf;

	for (;;) {

		/* find the end of the current line */

		for (p = q; q < end && *q != '\0'; ++q)

			if (*q == '\n')

				break;

		/* if we don't have a complete line, fill up the buffer */

		if (q >= end) {

			if (eof)

				break;

			if ((size_t)(q - p) >= sizeof(buf)) {

				warnx("group line too long");

				errno = EINVAL; /* hack */

				goto err;

			}

			if (p < end) {

				q = memmove(buf, p, end -p);

				end -= p - buf;

			} else {

				p = q = end = buf;

			}

			readlen = read(ffd, end, sizeof(buf) - (end -buf));

			if (readlen == -1)

				goto err;

			else

				len = (size_t)readlen;

			if (len == 0 && p == buf)

				break;

			end += len;

			len = end - buf;

			if (len < (ssize_t)sizeof(buf)) {

				eof = 1;

				if (len > 0 && buf[len -1] != '\n')

					++len, *end++ = '\n';

			}

			continue;

		}

		/* is it a blank line or a comment? */

		for (r = p; r < q && isspace(*r); ++r)

			/* nothing */;

		if (r == q || *r == '#') {

			/* yep */

			if (write(tfd, p, q -p + 1) != q - p + 1)

				goto err;

			++q;

			continue;

		}

		/* is it the one we're looking for? */

		t = *q;

		*q = '\0';

		fgr = gr_scan(r);

		/* fgr is either a struct group for the current line,

		 * or NULL if the line is malformed.

		 */

		*q = t;

		if (fgr == NULL || fgr->gr_gid != sgr->gr_gid) {

			/* nope */

			if (fgr != NULL)

				free(fgr);

			if (write(tfd, p, q - p + 1) != q - p + 1)

				goto err;

			++q;

			continue;

		}

		if (old_gr && !gr_equal(fgr, old_gr)) {

			warnx("entry inconsistent");

			free(fgr);

			errno = EINVAL; /* hack */

			goto err;

		}

		free(fgr);

		/* it is, replace or remove it */

		if (line != NULL) {

			len = strlen(line);

			if (write(tfd, line, len) != (int) len)

				goto err;

		} else {

			/* when removed, avoid the \n */

			q++;

		}

		/* we're done, just copy the rest over */

		for (;;) {

			if (write(tfd, q, end - q) != end - q)

				goto err;

			q = buf;

			readlen = read(ffd, buf, sizeof(buf));

			if (readlen == 0)

				break;

			else

				len = (size_t)readlen;

			if (readlen == -1)

				goto err;

			end = buf + len;

		}

		goto done;

	}

	/* if we got here, we didn't find the old entry */

	if (line == NULL) {

		errno = ENOENT;

		goto err;

	}

	len = strlen(line);

	if ((size_t)write(tfd, line, len) != len ||

	   write(tfd, "\n", 1) != 1)

		goto err;

 done:

	if (line != NULL)

		free(line);

	return (0);

 err:

	if (line != NULL)

		free(line);

	return (-1);

}

/*

 * Regenerate the group file

 */

int

gr_mkdb(void)

{

	return (rename(tempname, group_file));

}

/*

 * Clean up. Preserver errno for the caller's convenience.

 */

void

gr_fini(void)

{

	int serrno;

	if (!initialized)

		return;

	initialized = 0;

	serrno = errno;

	if (*tempname != '\0') {

		unlink(tempname);

		*tempname = '\0';

	}

	if (lockfd != -1)

		close(lockfd);

	errno = serrno;

}

/*-

 * Copyright (c) 2011-2012 Baptiste Daroussin <bapt@FreeBSD.org>

 * All rights reserved.

 * 

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer

 *    in this position and unchanged.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

int gr_copy(int __ffd, int _tfd, const struct group *_gr, struct group *_old_gr);

void gr_fini(void);

int gr_init(const char *_dir, const char *_master);

int gr_lock(void);

int gr_mkdb(void);

int gr_tmp(int _mdf);

/*-

 * Copyright (c) 2011-2012 Baptiste Daroussin <bapt@FreeBSD.org>

 * All rights reserved.

 * 

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer

 *    in this position and unchanged.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include <sys/param.h>

#include <sys/types.h> /* needed type libutl.h on 8.X */

#include <grp.h>

#include <pwd.h>

#include <libutil.h>

#include <string.h>

#ifndef HAVE_GRUTILS

#include "private/gr_util.h"

#endif

#include "pkg.h"

#include "private/event.h"

#include "private/pkg.h"

int

pkg_add_user_group(struct pkg *pkg)

{

	struct pkg_group *g = NULL;

	struct pkg_user *u = NULL;

	struct group *gr = NULL;

	struct passwd *pw = NULL;

	int tfd, pfd;

	/* loop just to check group and users contains string */

	while (pkg_groups(pkg, &g) == EPKG_OK) {

		if (g->gidstr[0] == '\0') {

			/*

			 * old style group ignorring, this is created from

			 * scripts

			 */

			return (EPKG_OK);

		}

	}

	/* loop just to check group and users contains string */

	while (pkg_users(pkg, &u) == EPKG_OK) {

		if (u->uidstr[0] == '\0') {

			/*

			 * old style group ignorring, this is created from

			 * scripts

			 */

			return (EPKG_OK);

		}

	}

	g = NULL;

	u = NULL;

	while (pkg_groups(pkg, &g) == EPKG_OK) {

		char *gr_create_str, *tmp;

		/* simply create the group */

		if ((gr = getgrnam(pkg_group_name(g))) == NULL) {

			/* remove the members if any */

			if (g->gidstr[strlen(g->gidstr) - 1] == ':') {

				gr = gr_scan(g->gidstr);

			} else {

				gr_create_str = strdup(g->gidstr);

				tmp = strrchr(gr_create_str, ':');

				tmp++;

				tmp[0] = '\0';

				gr = gr_scan(gr_create_str);

				free(gr_create_str);

			}

		} else {

			/* no need to create the group */

			continue;

		}

		if (gr == NULL) {

			pkg_emit_error("Bad group line, ignoring");

			continue;

		}

		gr_init(NULL, NULL);

		if ((pfd = gr_lock()) == -1) {

			gr_fini();

			continue;

		}

		if ((tfd = gr_tmp(-1)) == -1) {

			gr_fini();

			continue;

		}

		if (gr_copy(pfd, tfd, gr, NULL) == -1) {

			gr_fini();

			continue;

		}

		if (gr_mkdb() == -1) {

			gr_fini();

			continue;

		}

		free(gr);

		gr_fini();

	}

	while (pkg_users(pkg, &u) == EPKG_OK) {

		if ((pw = getpwnam(pkg_user_name(u))) == NULL) {

			/* simply create the user */

			pw = pw_scan(u->uidstr, PWSCAN_WARN|PWSCAN_MASTER);

		} else {

			/* user already exists */

			continue;

		}

		pw_init(NULL, NULL);

		if ((pfd = pw_lock()) == -1) {

			pw_fini();

			continue;

		}

		if ((tfd = gr_tmp(-1)) == -1) {

			pw_fini();

			continue;

		}

		if (pw_copy(pfd, tfd, pw, NULL) == -1) {

			pw_fini();

			continue;

		}

		if (pw_mkdb(pkg_user_name(u)) == -1) {

			pw_fini();

		}

		pw_fini();

		if (strcmp(pw->pw_dir, "/nonexistent") &&

		    strcmp(pw->pw_dir, "/var/empty")) {

			/* now create the homedir if it doesn't exists */

			/* TODO: do it recursively */

			mkdir(pw->pw_dir, 0644);

			chown(pw->pw_dir, pw->pw_uid, pw->pw_gid);

		}

		free(pw);

	}

	/* now add members to groups if they also are listed in users */

	g = NULL;

	while (pkg_groups(pkg, &g) == EPKG_OK) {

		struct group *grlocal;

		struct group *grnew;

		int i, j;

		int nx = 0;

		if (g->gidstr[strlen(g->gidstr) - 1] == ':')

			continue; /* no members, next */

		gr = gr_scan(g->gidstr);

		grlocal = getgrnam(pkg_group_name(g));

		grnew = NULL;/* gr_dup(grlocal);*/

		u = NULL;

		for (i = 0; gr->gr_mem[i] != NULL; i++) {

			while (pkg_users(pkg, &u) == EPKG_OK) {

				if (strcmp(pkg_user_name(u), gr->gr_mem[i]))

					continue;

				/*

				 * check if the user is not already in the

				 * local group

				 */

				for (j = 0; grlocal->gr_mem[j] != NULL; j++) {

					if (!strcmp(grlocal->gr_mem[j],

					    gr->gr_mem[i]))

						break;

				}

				if (grlocal->gr_mem[j] != NULL)

					continue; /* already in the group */

				/* adding the user to the group */

				if (grnew == NULL) {

					nx = j - 1;

					grnew = gr_dup(grlocal);

				}

				if (nx == 0)

					grnew->gr_mem = NULL;

				nx++;

				grnew->gr_mem = reallocf(grnew->gr_mem,

				    sizeof(*grnew->gr_mem) * (nx + 1));

				grnew->gr_mem[nx - 1] =

				    __DECONST(char *, pkg_user_name(u));

				grnew->gr_mem[nx] = NULL;

			}

		}

		if (grnew == NULL) {

			continue;

		}

		gr_init(NULL, NULL);

		if ((pfd = gr_lock()) == -1) {

			gr_fini();

			continue;

		}

		if ((tfd = gr_tmp(-1)) == -1) {

			gr_fini();

			continue;

		}

		if (gr_copy(pfd, tfd, grnew, grlocal) == -1) {

			gr_fini();

			continue;

		}

		if (gr_mkdb() == -1) {

			gr_fini();

			continue;

		}

		free(grnew);

		gr_fini();

	}

	return (EPKG_OK);

}