xref: /openbsd/regress/lib/libpthread/group/group.c (revision d0774bb2)

/*	$OpenBSD: group.c,v 1.6 2005/10/30 23:59:43 fgsch Exp $	*/

/* David Leonard <d@openbsd.org>, 2001. Public Domain. */

/*
 * Test getgrgid_r() across multiple threads to see if the members list changes.
 */

#include <sys/types.h>
#include <grp.h>
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include "test.h"

int	getgrgid_r(gid_t, struct group *, char *, size_t, struct group **);

char fail[] = "fail";

pthread_cond_t done;
volatile int done_count;

pthread_mutex_t display;
pthread_mutex_t display2;

static void *
test(void *arg)
{
	gid_t gid = *(gid_t *)arg;
	gid_t ogid;
	struct group grpbuf;
	struct group *grp;
	char **p;
	char buffer[5000];
	char buf[2048];
	char *cpy[128];
	int i;
	int count1, count2;
	char *s;
	char *oname;
	char *opasswd;
	size_t len;

	/* Acquire lock for running first part. */
	CHECKr(pthread_mutex_lock(&display));

	/* Store magic name to test for non-alteration */
	grpbuf.gr_name = fail;

	/* Call getgrgid_r() */
	printf("gid %d\n", gid);
	CHECKr(getgrgid_r(gid, &grpbuf, buffer, sizeof(buffer), &grp));

	/* Test for non-alteration of group structure */
	ASSERT(grp->gr_name != fail);

	/* We must get the right group */
	ASSERT(grp->gr_gid == gid);

	s = buf;	/* Keep our private buffer on the stack */
	len = sizeof(buf);

	/* copy gr_name */
	strlcpy(oname = s, grp->gr_name, len);
	len -= 1 + strlen(s);
	s += 1 + strlen(s);

	/* copy gr_passwd */
	strlcpy(opasswd = s, grp->gr_passwd, len);
	len -= 1 + strlen(s);
	s += 1 + strlen(s);

	/* copy gr_gid */
	ogid = grp->gr_gid;

	/* copy gr_mem */
	for (i = 0, p = grp->gr_mem; *p; p++) {
		strlcpy(cpy[i] = s, *p, len);
		i++;
		len -= 1 + strlen(s);
		s += 1 + strlen(s);
	}
	cpy[i] = NULL;

#if 0
	printf("now:    %s:%s:%d:", grp->gr_name, grp->gr_passwd, grp->gr_gid);
	for (p = grp->gr_mem; *p; p++)
		printf("%s%s", *p, *(p+1) == NULL ? "": ",");
	printf("\n");
#endif

#ifdef DEBUG /* debugging this program */
	printf("buf = \"");
	for (i = 0; i < s - buf; i++)
		if (buf[i] == '\0')	printf("\\0");
		else printf("%c", buf[i]);
	printf("\"\n");
#endif

	/* Inform main that we have finished */
	done_count++;
	CHECKr(pthread_cond_signal(&done));

	/* Allow other threads to run first part */
	CHECKr(pthread_mutex_unlock(&display));

	/* Acquire lock for the second part */
	CHECKr(pthread_mutex_lock(&display2));

	count1 = 0;
	printf("before: %s:%s:%d:", oname, opasswd, ogid);
	for (p = cpy; *p; p++)  {
		count1++;
		printf("%s%s", *p, *(p+1) == NULL ? "": ",");
	}
	printf("\n");

	count2 = 0;
	printf("after:  %s:%s:%d:", grp->gr_name, grp->gr_passwd, grp->gr_gid);
	for (p = grp->gr_mem; *p; p++)  {
		count2++;
		printf("%s%s", *p, *(p+1) == NULL ? "": ",");
	}
	printf("\n");

	CHECKr(pthread_mutex_unlock(&display2));

	if (count1 != count2)
		return "gr_mem length changed";
	for (i = 0; i < count1; i++)
		if (strcmp(cpy[i], grp->gr_mem[i]) != 0)
			return "gr_mem list changed";
	if (strcmp(grp->gr_name, oname) != 0)
		return "gr_name changed";
	if (strcmp(grp->gr_passwd, opasswd) != 0)
		return "gr_passwd changed";
	if (grp->gr_gid != ogid)
		return "gr_gid changed";
	return NULL;
}


#define NGRPS	5
int
main(int argc, char *argv[])
{
	pthread_t thread[NGRPS];
	int gid;
	int failed;
	void *result;

	CHECKr(pthread_mutex_init(&display, NULL));
	CHECKr(pthread_mutex_init(&display2, NULL));

	CHECKr(pthread_cond_init(&done, NULL));
	done_count = 0;

	pthread_mutex_lock(&display);
	pthread_mutex_lock(&display2);

	/* Get separate threads to do a group open separately */
	for (gid = 0; gid < NGRPS; gid++) {
		int *n = (int *)malloc(sizeof(int));
		*n = gid;

		CHECKr(pthread_create(&thread[gid], NULL, test, (void *)n));
	}

	/* Allow all threads to run their first part */
	while (done_count < NGRPS)
		pthread_cond_wait(&done, &display);

	/* Allow each thread to run the 2nd part of its test */
	CHECKr(pthread_mutex_unlock(&display2));

	/* Wait for each thread to terminate, collecting results. */
	failed = 0;
	for (gid = 0; gid < NGRPS; gid++) {
		CHECKr(pthread_join(thread[gid], &result));
		if (result != NULL) {
			fprintf(stderr, "gid %d: %s\n", gid, (char *)result);
			failed++;
		}
	}

	if (!failed) {
		SUCCEED;
	} else {
		exit(1);
	}
}