int
main(void)
{
char *strGrp;
int testNdx;
struct group *dupGrp;
struct group *scanGrp;
struct group origGrp;
/* Setup. */
printf("1..4\n");
testNdx = 0;
/* Manually build a group using static values. */
build_grp(&origGrp);
/* Copy the group. */
testNdx++;
if ((dupGrp = gr_dup(&origGrp)) == NULL)
printf("not ");
printf("ok %d - %s\n", testNdx, "gr_dup");
/* Compare the original and duplicate groups. */
testNdx++;
if (! gr_equal(&origGrp, dupGrp))
printf("not ");
printf("ok %d - %s\n", testNdx, "gr_equal");
/* Create group string from the duplicate group structure. */
testNdx++;
strGrp = gr_make(dupGrp);
if (strcmp(strGrp, origStrGrp) != 0)
printf("not ");
printf("ok %d - %s\n", testNdx, "gr_make");
/*
* Create group structure from string and compare it to the original
* group structure.
*/
testNdx++;
if ((scanGrp = gr_scan(strGrp)) == NULL || ! gr_equal(&origGrp,
scanGrp))
printf("not ");
printf("ok %d - %s\n", testNdx, "gr_scan");
/* Clean up. */
free(scanGrp);
free(strGrp);
free(dupGrp);
exit(EXIT_SUCCESS);
}
static struct group *
vnextgrent(char const *nam, gid_t gid, int doclose)
{
struct group *gr;
char *line;
size_t linecap;
ssize_t linelen;
gr = NULL;
line = NULL;
linecap = 0;
linelen = 0;
if (grp_fp != NULL || (grp_fp = fopen(getgrpath(_GROUP), "r")) != NULL) {
while ((linelen = getline(&line, &linecap, grp_fp)) > 0) {
/* Skip comments and empty lines */
if (*line == '\n' || *line == '#')
continue;
/* trim latest \n */
if (line[linelen - 1 ] == '\n')
line[linelen - 1] = '\0';
gr = gr_scan(line);
if (gid != (gid_t)-1) {
if (gid == gr->gr_gid)
break;
} else if (nam != NULL) {
if (strcmp(nam, gr->gr_name) == 0)
break;
} else
break;
free(gr);
gr = NULL;
}
if (doclose)
vendgrent();
}
free(line);
return (gr);
}
/*
* 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;
if (old_gr == NULL && gr == NULL)
return(-1);
sgr = old_gr;
/* deleting a group */
if (gr == NULL) {
line = NULL;
} else {
if ((line = gr_make(gr)) == NULL)
return (-1);
}
/* adding a group */
if (sgr == NULL)
sgr = gr;
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);
}
