void UserGroupDialog::fillListView ( )
{
if ( _type == User )
{
struct passwd *pwd = getpwent ( );
while ( pwd )
{
QListViewItem *item = new QListViewItem ( listView, QString ( ).setNum ( pwd->pw_uid ), pwd->pw_name );
listView->insertItem ( item );
pwd = getpwent ( );
}
}
else
{
struct group *grp = getgrent ( );
while ( grp )
{
QListViewItem *item = new QListViewItem ( listView, QString ( ).setNum ( grp->gr_gid ), grp->gr_name );
listView->insertItem ( item );
grp = getgrent ( );
}
}
}
bool
authcursor_etc_group::next (bool *pep)
{
if (ae.type != SFSAUTH_GROUP) {
min_getgrent = 0;
setgrent ();
}
else if (lastcursor != this) {
//struct group *gp;
setgrent ();
for (int i = 0; i < min_getgrent; i++)
getgrent ();
#if 0
do {
gp = getgrent ();
//warn << ae.groupinfo->name << " =? " << gp->gr_name << "\n";
if (!gp) {
if (pep)
*pep = true;
return false;
}
} while (ae.groupinfo->name != gp->gr_name);
#endif
}
min_getgrent++;
return setae (getgrent ());
}
static int
setgroups_if_single_user(void)
{
int i, retval = -1;
struct group *grp;
gid_t gids[NUM_GROUPS];
if (!_ds_running()) {
printf("In single-user mode.\n");
g_is_single_user = 1;
/* We skip 'nobody' and 'anyone' */
getgrent();
getgrent();
for (i = 0; i < NUM_GROUPS; i++) {
grp = getgrent();
if (!grp) {
break;
}
gids[i] = grp->gr_gid;
}
endgrent();
/* Only succeed if we find at least NUM_GROUPS */
if (i == NUM_GROUPS) {
retval = setgroups(NUM_GROUPS, gids);
if (retval == 0) {
getgroups(NUM_GROUPS, gids);
printf("After single-user hack, groups are: ");
for (i = 0; i < NUM_GROUPS; i++) {
printf("%d, ", gids[i]);
}
putchar('\n');
} else {
printf("Setgroups failed.\n");
}
} else {
printf("Couldn't get sufficient number of groups.\n");
}
} else {
printf("Not in single user mode.\n");
retval = 0;
}
return retval;
}
static int
get_user_groups (const struct passwd *pw, gid_t* glist, size_t gmax)
{
int num = 0;
struct group *gr;
char **mem;
glist[num++] = pw->pw_gid;
for ( gr = getgrent(); (gr != NULL) && (num < gmax); gr = getgrent() ) {
if (gr->gr_gid == pw->pw_gid) continue;
for (mem = gr->gr_mem; *mem; mem++) {
if(!strcmp(*mem, pw->pw_name)) glist[num++] = gr->gr_gid;
}
}
return num;
}
static int
group(int argc, char *argv[])
{
struct group *gr;
unsigned long id;
int i, rv;
assert(argc > 1);
assert(argv != NULL);
#define GROUPPRINT printfmtstrings(gr->gr_mem, ":", ",", "%s:%s:%u", \
gr->gr_name, gr->gr_passwd, gr->gr_gid)
setgroupent(1);
rv = RV_OK;
if (argc == 2) {
while ((gr = getgrent()) != NULL)
GROUPPRINT;
} else {
for (i = 2; i < argc; i++) {
if (parsenum(argv[i], &id))
gr = getgrgid((gid_t)id);
else
gr = getgrnam(argv[i]);
if (gr != NULL)
GROUPPRINT;
else {
rv = RV_NOTFOUND;
break;
}
}
}
endgrent();
return rv;
}
static int juti_getgrouplist(const char *uname, gid_t agroup, gid_t **groups_res, char*** group_names_res, int *grpcnt)
{
struct group *grp;
int bail;
int ret = 0;
int maxgroups = 0;
gid_t *groups = NULL;
char **group_names = NULL;
int ngroups = 0;
int i = 0;
setgrent();
while ((grp = getgrent())) {
for (bail = 0, i = 0; bail == 0 && i < ngroups; i++) {
if (groups[i] == grp->gr_gid) {
bail = 1;
}
}
if (bail) {
continue;
}
if (grp->gr_gid == agroup) {
if(add_group(grp, &groups, &group_names, &ngroups, &maxgroups) != 0) {
ret = -1;
goto error;
}
continue;
}
for (i = 0; grp->gr_mem[i]; i++) {
if (strcmp(grp->gr_mem[i], uname) == 0) {
if(add_group(grp, &groups, &group_names, &ngroups, &maxgroups) != 0) {
ret = -1;
goto error;
}
}
}
}
endgrent();
error:
if (ret != 0) {
if (groups != NULL) {
free(groups);
}
for (i=0; i < ngroups; i++) {
free(group_names[i]);
}
if (group_names != NULL) {
free(group_names);
}
} else {
*groups_res = groups;
*group_names_res = group_names;
*grpcnt = ngroups;
}
return ret;
}
int cvm_module_results(void)
{
char* tmp;
if ((tmp = strchr(pw->pw_gecos, ',')) != 0)
*tmp = 0;
cvm_fact_username = pw->pw_name;
cvm_fact_userid = pw->pw_uid;
cvm_fact_groupid = pw->pw_gid;
cvm_fact_realname = pw->pw_gecos;
cvm_fact_directory = pw->pw_dir;
cvm_fact_shell = pw->pw_shell;
cvm_module_fact_uint(CVM_FACT_SUPP_GROUPID, pw->pw_gid);
if (cvm_fact_groupname) free((char*)cvm_fact_groupname);
cvm_fact_groupname = 0;
setgrent();
while ((gr = getgrent()) != 0) {
if (gr->gr_gid == pw->pw_gid)
cvm_fact_groupname = strdup(gr->gr_name);
else {
unsigned i;
for (i = 0; gr->gr_mem[i]; i++)
if (strcmp(gr->gr_mem[i], pw->pw_name) == 0) {
cvm_module_fact_uint(CVM_FACT_SUPP_GROUPID, gr->gr_gid);
break;
}
}
}
endgrent();
return 0;
}
int initgroups(const char *name, gid_t basegid)
{
#if defined(QNX) || defined(MPE) || defined(BEOS) || defined(_OSD_POSIX) || defined(TPF) || defined(__TANDEM) || defined(OS2) || defined(WIN32) || defined(NETWARE)
/* QNX, MPE and BeOS do not appear to support supplementary groups. */
return 0;
#else /* ndef QNX */
gid_t groups[NGROUPS_MAX];
struct group *g;
int index = 0;
setgrent();
groups[index++] = basegid;
while (index < NGROUPS_MAX && ((g = getgrent()) != NULL)) {
if (g->gr_gid != basegid) {
char **names;
for (names = g->gr_mem; *names != NULL; ++names) {
if (!strcmp(*names, name))
groups[index++] = g->gr_gid;
}
}
}
endgrent();
return setgroups(index, groups);
#endif /* def QNX */
}
RmUserList *rm_userlist_new(void) {
struct passwd *node = NULL;
struct group *grp = NULL;
RmUserList *self = g_malloc0(sizeof(RmUserList));
self->users = g_sequence_new(NULL);
self->groups = g_sequence_new(NULL);
g_mutex_init(&self->mutex);
setpwent();
while((node = getpwent()) != NULL) {
g_sequence_insert_sorted(
self->users, GUINT_TO_POINTER(node->pw_uid), rm_userlist_cmp_ids, NULL
);
g_sequence_insert_sorted(
self->groups, GUINT_TO_POINTER(node->pw_gid), rm_userlist_cmp_ids, NULL
);
}
endpwent();
/* add all groups, not just those that are user primary gid's */
while((grp = getgrent()) != NULL) {
g_sequence_insert_sorted(
self->groups, GUINT_TO_POINTER(grp->gr_gid), rm_userlist_cmp_ids, NULL
);
}
endgrent();
return self;
}
/*
* mygetgroups() -- get the supplemental group list for
* the given user id.
*/
int
mygetgroups(uid_t uid, gid_t grps[], int nr_grps)
{
struct group *grp;
struct passwd *pwd = getpwuid(uid);
int x;
int totgrp = 0;
if (pwd == 0)
return 0;
setgrent();
while ( (grp = getgrent()) != 0) {
#if 0
if (grp->gr_gid == pwd->pw_gid)
continue;
#endif
for (x=0; grp->gr_mem[x]; x++)
if (strcmp(grp->gr_mem[x], pwd->pw_name) == 0) {
if (totgrp >= nr_grps)
return totgrp;
grps[totgrp++] = grp->gr_gid;
break;
}
}
return totgrp;
} /* mygetgroups */
static int
_getgroups(char *uname, gid_t groups[NGRPS])
{
gid_t ngroups = 0;
struct group *grp;
int i;
int j;
int filter;
setgrent();
while ((grp = getgrent())) {
for (i = 0; grp->gr_mem[i]; i++)
if (!strcmp(grp->gr_mem[i], uname)) {
if (ngroups == NGRPS) {
#ifdef DEBUG
fprintf(stderr,
"initgroups: %s is in too many groups\n", uname);
#endif
goto toomany;
}
/* filter out duplicate group entries */
filter = 0;
for (j = 0; j < ngroups; j++)
if (groups[j] == grp->gr_gid) {
filter++;
break;
}
if (!filter)
groups[ngroups++] = grp->gr_gid;
}
}
toomany:
endgrent();
return (ngroups);
}
static void print_groups (const char *member)
{
int groups = 0;
struct group *grp;
struct passwd *pwd;
int flag = 0;
setgrent ();
if ((pwd = getpwnam (member)) == 0) {
fprintf (stderr, _("unknown user %s\n"), member);
exit (1);
}
while ((grp = getgrent ())) {
if (is_on_list (grp->gr_mem, member)) {
if (groups++)
putchar (' ');
printf ("%s", grp->gr_name);
if (grp->gr_gid == pwd->pw_gid)
flag = 1;
}
}
if (!flag && (grp = getgrgid (pwd->pw_gid))) {
if (groups++)
putchar (' ');
printf ("%s", grp->gr_name);
}
if (groups)
putchar ('\n');
}
/* 1 if user belongs to the group, 0 otherwise) */
static int user_belongs_to_group(uid_t uid, gid_t gid)
{
struct passwd *pw=getpwuid(uid);
if (pw == NULL)
return 0;
else {
if (gid==pw->pw_gid)
return 1;
else {
struct group *grp;
setgrent();
while ((grp = getgrent())) {
if (grp->gr_gid == gid) {
int i;
for (i = 0; grp->gr_mem[i]; i++) {
if (strcmp(grp->gr_mem[i], pw->pw_name)==0) {
endgrent();
return 1;
}
}
}
}
endgrent();
return 0;
}
}
}
static int _getgrouplist(const char*user,gid_t group,gid_t*groups,int*ngroups) {
long n=0,size=*ngroups;
struct group*g;
int ret=0;
if (0<size) { groups[n++]=group; }
else { *ngroups=0; return (-1); }
setgrent();
while ((g=getgrent())) {
char **duh;
if (g->gr_gid==group) continue;
duh=g->gr_mem;
while (*duh) {
if (!strcmp(*duh,user)) {
if (n>=size) {
ret=~ret;
goto err_out;
}
groups[n++]=g->gr_gid;
break;
}
duh++;
}
}
err_out:
endgrent();
*ngroups=n;
return ret;
}
int
initgroups(const char* user, gid_t additional_group)
{
if (geteuid() != 0) {
errno = EPERM;
return -1;
}
const int max_number_of_groups = 32;
gid_t groups[max_number_of_groups + 1];
setgrent();
struct group* group;
int next_to_add = 0;
int add_additional = 1;
while ((group = getgrent())) {
for (int i = 0; group->gr_mem[i]; ++i) {
if (strcmp(group->gr_mem[i], user) == 0) {
groups[next_to_add++] = group->gr_gid;
if (group->gr_gid == additional_group) {
add_additional = 0;
}
}
}
}
if (add_additional) {
groups[next_to_add++] = additional_group;
}
setgroups(next_to_add, groups);
return 0;
}
struct sys_userlist *get_users_in_group(const char *gname)
{
struct sys_userlist *list_head = NULL;
struct group *gptr;
/*
* If we're doing this via winbindd, don't do the
* entire group list enumeration as we know this is
* pointless (and slow).
*/
if (strchr(gname,*lp_winbind_separator())) {
if ((gptr = (struct group *)getgrnam(gname)) == NULL)
return NULL;
return add_members_to_userlist(list_head, gptr);
}
#if !defined(BROKEN_GETGRNAM)
if ((gptr = (struct group *)getgrnam(gname)) == NULL)
return NULL;
return add_members_to_userlist(list_head, gptr);
#else
setgrent();
while((gptr = getgrent()) != NULL) {
if (strequal(gname, gptr->gr_name)) {
list_head = add_members_to_userlist(list_head, gptr);
if (list_head == NULL)
return NULL;
}
}
endgrent();
return list_head;
#endif
}
static void
get_groups(void)
{
struct group *grp;
size_t len;
int i;
setgrent();
for (;;) {
if (ngrps == grpsz) {
grpsz += grpsz ? grpsz : 128;
grps = xrealloc(grps, grpsz * sizeof *grps);
}
if ((grp = getgrent()) == NULL)
break;
grps[ngrps].gr_name = xstrdup(grp->gr_name);
grps[ngrps].gr_passwd = xstrdup(grp->gr_passwd);
grps[ngrps].gr_gid = grp->gr_gid;
grps[ngrps].gr_mem = xstrdup("");
for (i = 0, len = 1; grp->gr_mem[i] != NULL; ++i)
len += strlen(grp->gr_mem[i]) + 1;
grps[ngrps].gr_mem = xmalloc(len);
for (i = 0, len = 0; grp->gr_mem[i] != NULL; ++i)
len += sprintf(grps[ngrps].gr_mem + len,
i ? ",%s" : "%s", grp->gr_mem[i]);
grps[ngrps].gr_mem[len] = '\0';
ngrps++;
}
endgrent();
}
void main(int argc, char *argv[])
{
uid_t uid;
gid_t gid;
struct passwd *u;
struct group *g;
char *member;
uid = getuid();
printf("uid=%d", uid);
u = getpwuid(uid);
printf("(%s) ", u->pw_name);
gid = getgid();
printf("gid=%d", gid);
g = getgrgid(gid);
printf("(%s) ", g->gr_name);
printf("groups=");
while ((g = getgrent()) != NULL) {
// printf("%s\n", g->gr_name);
while((member = *(g->gr_mem)++) != NULL)
if (strcmp(member, u->pw_name) == 0)
printf("%d(%s),", g->gr_gid, g->gr_name);
}
printf("\n");
}
static bool GroupGetUserMembership (const char *user, StringSet *result)
{
bool ret = true;
struct group *group_info;
setgrent();
while (true)
{
errno = 0;
group_info = getgrent();
if (!group_info)
{
if (errno)
{
Log(LOG_LEVEL_ERR, "Error while getting group list. (getgrent: '%s')", GetErrorStr());
ret = false;
}
break;
}
for (int i = 0; group_info->gr_mem[i] != NULL; i++)
{
if (strcmp(user, group_info->gr_mem[i]) == 0)
{
StringSetAdd(result, xstrdup(group_info->gr_name));
break;
}
}
}
endgrent();
return ret;
}
int initgroups(const char *name, gid_t basegid)
{
struct group *gr;
int r, found = 0;
if((r = setgid(basegid)) < 0)
return r;
setgrent();
while (!found && (gr = getgrent()) != NULL) {
char **mem;
for(mem = gr->gr_mem; mem && *mem; mem++) {
if(!strcmp(name, *mem)) {
found = 1;
break;
}
}
}
endgrent();
/* Because supplemental groups aren't implemented, this call
* should fail if the user is in any supplemental groups.
*/
if(found) {
errno = EINVAL;
return -1;
}
return 0;
}
static void function (LIST * list, regexp * regex, flag_t flags)
{
char const * string;
if (_anyset (flags, WHOM_B_USR))
{
struct passwd * passwd;
while ((passwd = getpwent ()))
{
string = regexspan (regex, passwd->pw_name);
if ((string) && (! * string))
{
listinsert (list, passwd->pw_name);
}
}
}
if (_anyset (flags, WHOM_B_GRP))
{
struct group * group;
while ((group = getgrent ()))
{
string = regexspan (regex, group->gr_name);
if ((string) && (! * string))
{
listinsert (list, group->gr_name);
}
}
}
return;
}
static BOOL user_in_group_list(char *user,char *gname)
{
#ifdef HAVE_GETGRENT
struct group *gptr;
char **member;
struct passwd *pass = Get_Pwnam(user,False);
if (pass) {
gptr = getgrgid(pass->pw_gid);
if (gptr && strequal(gptr->gr_name,gname))
return(True);
}
setgrent();
while ((gptr = (struct group *)getgrent())) {
if (!strequal(gptr->gr_name,gname))
continue;
member = gptr->gr_mem;
while (member && *member) {
if (strequal(*member,user)) {
endgrent();
return(True);
}
member++;
}
}
endgrent();
#endif /* HAVE_GETGRNAM */
return False;
}
static int
group(int argc, char *argv[])
{
int i, rv = RV_OK;
struct group *gr;
setgroupent(1);
if (argc == 2) {
while ((gr = getgrent()) != NULL)
GROUPPRINT;
} else {
for (i = 2; i < argc; i++) {
const char *err;
long long id = strtonum(argv[i], 0, UINT_MAX, &err);
if (!err)
gr = getgrgid((gid_t)id);
else
gr = getgrnam(argv[i]);
if (gr != NULL)
GROUPPRINT;
else {
rv = RV_NOTFOUND;
break;
}
}
}
endgrent();
return rv;
}
int initgroups(const char *name, gid_t basegid)
{
#ifdef HAVE_SETGROUPS
#ifndef NGROUPS_MAX
#define NGROUPS_MAX 16
#endif
gid_t groups[NGROUPS_MAX];
struct group *g;
int index = 0;
setgrent();
groups[index++] = basegid;
while (index < NGROUPS_MAX && ((g = getgrent()) != NULL)) {
if (g->gr_gid != basegid) {
char **names;
for (names = g->gr_mem; *names != NULL; ++names) {
if (!strcmp(*names, name))
groups[index++] = g->gr_gid;
}
}
}
endgrent();
return setgroups(index, groups);
#else
return 0;
#endif /* def HAVE_SETGROUPS */
}
int initgroups(const char *name, gid_t basegid)
{
#if defined(_OSD_POSIX) || defined(OS2) || defined(WIN32) || defined(NETWARE)
return 0;
#else
gid_t groups[NGROUPS_MAX];
struct group *g;
int index = 0;
setgrent();
groups[index++] = basegid;
while (index < NGROUPS_MAX && ((g = getgrent()) != NULL)) {
if (g->gr_gid != basegid) {
char **names;
for (names = g->gr_mem; *names != NULL; ++names) {
if (!strcmp(*names, name))
groups[index++] = g->gr_gid;
}
}
}
endgrent();
return setgroups(index, groups);
#endif
}
int main(int argc, char *argv[]) {
struct group *grp;
char **tmp_memb;
FILE *fp;
char file_grp[] = "group_db.txt";
if ((fp = fopen(file_grp, "w+")) == NULL) {
fprintf(stderr, "Err.(%s): %s\n", strerror(errno), file_grp);
exit(EXIT_FAILURE);
}
while ((grp = getgrent()) != NULL) {
fprintf(fp, "%30s | ", grp->gr_name);
fprintf(fp, "%s | ", grp->gr_passwd);
fprintf(fp, "%5d | ", grp->gr_gid);
tmp_memb = grp->gr_mem;
while (*tmp_memb != NULL) {
fprintf(fp, "%s, ", *tmp_memb);
tmp_memb++;
}
fprintf(fp, "\n");
}
printf("User Group file \'%s\' written.\n", file_grp);
endgrent();
fclose(fp);
free(*tmp_memb);
return(EXIT_SUCCESS);
}
main()
{
struct group *grp;
while (grp = getgrent()) {
printf("%s : %d\n", grp->gr_name, (int)grp->gr_gid);
}
return 0;
}
static int _refresh_group(Properties * properties, gid_t gid,
gboolean sensitive)
{
GtkWidget * combo;
GtkListStore * store;
int i = 0;
int active;
struct passwd * pw;
struct group * gr;
char ** p;
/* FIXME the group may not be modifiable (sensitive) or in the list */
combo = properties->group;
store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo)));
gtk_list_store_clear(store);
if((gr = getgrgid(getgid())) == NULL)
return -_properties_error(properties, properties->filename, 1);
#if GTK_CHECK_VERSION(2, 24, 0)
gtk_combo_box_text_insert_text(GTK_COMBO_BOX_TEXT(combo), i,
gr->gr_name);
#else
gtk_combo_box_insert_text(GTK_COMBO_BOX(combo), i, gr->gr_name);
#endif
active = i++;
if((pw = getpwuid(getuid())) == NULL)
return -_properties_error(properties, properties->filename, 1);
setgrent();
for(gr = getgrent(); gr != NULL; gr = getgrent())
for(p = gr->gr_mem; p != NULL && *p != NULL; p++)
if(strcmp(pw->pw_name, *p) == 0)
{
if(gid == gr->gr_gid)
active = i;
#if GTK_CHECK_VERSION(2, 24, 0)
gtk_combo_box_text_insert_text(
GTK_COMBO_BOX_TEXT(combo),
i++, gr->gr_name);
#else
gtk_combo_box_insert_text(GTK_COMBO_BOX(combo),
i++, gr->gr_name);
#endif
}
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), active);
gtk_widget_set_sensitive(combo, sensitive);
return 0;
}
struct group *getgrgid(gid_t gid)
{
struct group *gr;
setgrent();
while ((gr=getgrent()) && gr->gr_gid != gid);
endgrent();
return gr;
}
struct group *getgrnam(const char *name)
{
struct group *gr;
setgrent();
while ((gr=getgrent()) && strcmp(gr->gr_name, name));
endgrent();
return gr;
}
