bool _net_nfc_app_util_change_file_owner_permission(FILE *file)
{
	char *buffer = NULL;
	size_t buffer_len = 0;
	struct passwd pwd = { 0, };
	struct passwd *pw_inhouse = NULL;
	struct group grp = { 0, };
	struct group *gr_inhouse = NULL;

	if (file == NULL)
		return false;

	/* change permission */
	fchmod(fileno(file), 0777);

	/* change owner */
	/* get passwd id */
	buffer_len = sysconf(_SC_GETPW_R_SIZE_MAX);
	if (buffer_len == -1)
	{
		buffer_len = 16384;
	}

	_net_nfc_util_alloc_mem(buffer, buffer_len);
	if (buffer == NULL)
		return false;

	getpwnam_r("inhouse", &pwd, buffer, buffer_len, &pw_inhouse);
	_net_nfc_util_free_mem(buffer);

	/* get group id */
	buffer_len = sysconf(_SC_GETGR_R_SIZE_MAX);
	if (buffer_len == -1)
	{
		buffer_len = 16384;
	}

	_net_nfc_util_alloc_mem(buffer, buffer_len);
	if (buffer == NULL)
		return false;

	getgrnam_r("inhouse", &grp, buffer, buffer_len, &gr_inhouse);
	_net_nfc_util_free_mem(buffer);

	if ((pw_inhouse != NULL) && (gr_inhouse != NULL))
	{
		if (fchown(fileno(file), pw_inhouse->pw_uid, gr_inhouse->gr_gid) < 0)
		{
			DEBUG_ERR_MSG("failed to change owner");
		}
	}

	return true;
}
static gid_t getGroupId(const char *name, gid_t fallback)
{
    struct group group, *grpptr;
    size_t size = sysconf(_SC_GETGR_R_SIZE_MAX);
    char buf[size];

    if (getgrnam_r(name, &group, buf, size, &grpptr) == 0 && grpptr != NULL)
        return group.gr_gid;
    else
        return fallback;
}
Beispiel #3
0
int chown_path(const char* pathname, const char* ownername, const char* groupname) {
	struct passwd pwd;
	struct passwd* pwd_result;
	char* pwd_buf;
	long int pwd_bufsize;
	struct group grp;
	struct group* grp_result;
	char* grp_buf;
	long int grp_bufsize;
	int result = 1;

	pwd_bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
	if (pwd_bufsize == -1) {
		pwd_bufsize = 1<<14;
	}

	pwd_buf = malloc((size_t)pwd_bufsize);
	if (pwd_buf == NULL) {
		LOG(MOD "Unable to allocate memory for passwd buffer\n");
		return 1;
	}

	getpwnam_r(ownername, &pwd, pwd_buf, (size_t)pwd_bufsize, &pwd_result);
	if (pwd_result == NULL) {
		LOG(MOD "User not found '%s'\n", ownername);
		goto fail1;
	}

	grp_bufsize = sysconf(_SC_GETGR_R_SIZE_MAX);
	if (grp_bufsize == -1) {
		grp_bufsize = 1<<14;
	}

	grp_buf = malloc((size_t)grp_bufsize);
	if (grp_buf == NULL) {
		LOG(MOD "Unable to allocate memory for group buffer\n");
		goto fail1;
	}

	getgrnam_r(groupname, &grp, grp_buf, (size_t)grp_bufsize, &grp_result);
	if (grp_result == NULL) {
		LOG(MOD "Group not found '%s'\n", groupname);
		goto fail2;
	}

	result = chown(pathname, pwd.pw_uid, grp.gr_gid);

fail2:
	free(grp_buf);
fail1:
	free(pwd_buf);
	return result;
}
Beispiel #4
0
/* extract a groupname and return its gid.
 * rgerhards, 2007-07-17
 */
static rsRetVal doGetGID(uchar **pp, rsRetVal (*pSetHdlr)(void*, uid_t), void *pVal)
{
	struct group *pgBuf = NULL;
	struct group gBuf;
	DEFiRet;
	uchar szName[256];
	int bufSize = 1024;
	char * stringBuf = NULL;
	int err;

	assert(pp != NULL);
	assert(*pp != NULL);

	if(getSubString(pp, (char*) szName, sizeof(szName), ' ')  != 0) {
		errmsg.LogError(0, RS_RET_NOT_FOUND, "could not extract group name");
		ABORT_FINALIZE(RS_RET_NOT_FOUND);
	}

	do {
		char *p;

		/* Increase bufsize and try again.*/
		bufSize *= 2;
		CHKmalloc(p = realloc(stringBuf, bufSize));
		stringBuf = p;
		err = getgrnam_r((char*)szName, &gBuf, stringBuf, bufSize, &pgBuf);
	} while((pgBuf == NULL) && (err == ERANGE));

	if(pgBuf == NULL) {
		if (err != 0) {
			errmsg.LogError(err, RS_RET_NOT_FOUND, "Query for group '%s' resulted in an error",
				szName);
		} else {
			errmsg.LogError(0, RS_RET_NOT_FOUND, "ID for group '%s' could not be found", szName);
		}
		iRet = RS_RET_NOT_FOUND;
	} else {
		if(pSetHdlr == NULL) {
			/* we should set value directly to var */
			*((gid_t*)pVal) = pgBuf->gr_gid;
		} else {
			/* we set value via a set function */
			CHKiRet(pSetHdlr(pVal, pgBuf->gr_gid));
		}
		dbgprintf("gid %d obtained for group '%s'\n", (int) pgBuf->gr_gid, szName);
	}

	skipWhiteSpace(pp); /* skip over any whitespace */

finalize_it:
	free(stringBuf);
	RETiRet;
}
Beispiel #5
0
static int gid_determine (const char *req_group)
{
    int corosync_gid = 0;
    struct group group;
    struct group * grpptr = &group;
    struct group * temp_grp_pt;
    char *grpbuffer;
    int  grplinelen, rc;
    long int id;
    char *ep;

    id = strtol(req_group, &ep, 10);
    if (*ep == '\0' && id >= 0 && id <= UINT_MAX) {
        return (id);
    }

    grplinelen = sysconf (_SC_GETGR_R_SIZE_MAX);

    if (grplinelen == -1) {
        grplinelen = 256;
    }

    grpbuffer = malloc (grplinelen);

    while ((rc = getgrnam_r (req_group, grpptr, grpbuffer, grplinelen, &temp_grp_pt)) == ERANGE) {
        char *n;

        grplinelen *= 2;
        if (grplinelen <= 32678) {
            n = realloc (grpbuffer, grplinelen);
            if (n != NULL) {
                grpbuffer = n;
                continue;
            }
        }
    }
    if (rc != 0) {
        free (grpbuffer);
        sprintf (error_string_response, "getgrnam_r(): %s", strerror(rc));
        return (-1);
    }
    if (temp_grp_pt == NULL) {
        free (grpbuffer);
        sprintf (error_string_response,
                 "The '%s' group is not found in /etc/group, please read the documentation.",
                 req_group);
        return (-1);
    }
    corosync_gid = group.gr_gid;
    free (grpbuffer);

    return corosync_gid;
}
Beispiel #6
0
int i_getgrnam(const char *name, struct group *grp_r)
{
	struct group *result;

	errno = 0;
	do {
		gr_init();
		errno = getgrnam_r(name, grp_r, grbuf, grbuf_size, &result);
	} while (errno == ERANGE);
	if (result != NULL)
		return 1;
	return errno == 0 ? 0 : -1;
}
Beispiel #7
0
static gid_t
get_gid_from_archive(struct archive_entry *ae)
{
	char buffer[128];
	struct group grent, *result;

	if ((getgrnam_r(archive_entry_gname(ae), &grent, buffer, sizeof(buffer),
	    &result)) < 0)
		return (0);
	if (result == NULL)
		return (0);
	return (grent.gr_gid);
}
static void
group_option(char *value, struct request_info *request)
{
    struct group grs, *grp;
    char grbuf[1024];

    (void)getgrnam_r(value, &grs, grbuf, sizeof(grbuf), &grp);
    if (grp == NULL)
	tcpd_jump("unknown group: \"%s\"", value);

    if (dry_run == 0 && setgid(grp->gr_gid))
	tcpd_jump("setgid(%s): %m", value);
}
Beispiel #9
0
gboolean
ves_icall_System_Security_Principal_WindowsPrincipal_IsMemberOfGroupName (gpointer user, MonoString *group)
{
    gboolean result = FALSE;

#ifdef HOST_WIN32

    MONO_ARCH_SAVE_REGS;

    /* Windows version use a cache built using WindowsIdentity._GetRoles */
    g_warning ("IsMemberOfGroupName should never be called on Win32");

#else /* HOST_WIN32 */
    gchar *utf8_groupname;

    MONO_ARCH_SAVE_REGS;

    utf8_groupname = mono_unicode_to_external (mono_string_chars (group));
    if (utf8_groupname) {
        struct group *g = NULL;
#ifdef HAVE_GETGRNAM_R
        struct group grp;
        gchar *fbuf;
        gint32 retval;
#ifdef _SC_GETGR_R_SIZE_MAX
        size_t fbufsize = mono_sysconf (_SC_GETGR_R_SIZE_MAX);
#else
        size_t fbufsize = MONO_SYSCONF_DEFAULT_SIZE;
#endif
        fbuf = g_malloc0 (fbufsize);
        retval = getgrnam_r (utf8_groupname, &grp, fbuf, fbufsize, &g);
        result = ((retval == 0) && (g == &grp));
#else
        /* default to non thread-safe but posix compliant function */
        g = getgrnam (utf8_groupname);
        result = (g != NULL);
#endif

        if (result) {
            result = IsMemberOf ((uid_t) GPOINTER_TO_INT (user), g);
        }

#ifdef HAVE_GETGRNAM_R
        g_free (fbuf);
#endif
        g_free (utf8_groupname);
    }
#endif /* HOST_WIN32 */

    return result;
}
Beispiel #10
0
static gid_t gid_by_name(const char* name) {
  struct group pwd;
  struct group* pp;
  char buf[8192];

  errno = 0;
  pp = NULL;

  if (getgrnam_r(name, &pwd, buf, sizeof(buf), &pp) == 0 && pp != NULL) {
    return pp->gr_gid;
  }

  return gid_not_found;
}
Beispiel #11
0
static int
drop_privs_r(const char *username,const char *groupname,size_t buflen){
	struct passwd pwent,*pdb = NULL;
	struct group grent,*grp = NULL;
	uid_t uid,olduid = getuid();
	gid_t gid,oldgid = getgid();
	char buf[buflen];

	if(groupname){
		if(getgrnam_r(groupname,&grent,buf,sizeof(buf),&grp) || !grp){
			moan("Couldn't look up group %s\n",groupname);
			return -1;
		}
		gid = grp->gr_gid;
		if(setgid(gid)){
			moan("Couldn't setgid to group %d\n",gid);
			return -1;
		}
		if(getgid() != gid){
			bitch("getgid() returned %d, not %d\n",getgid(),gid);
			return -1;
		}
		if(getegid() != gid){
			bitch("getegid() returned %d, not %d\n",getegid(),gid);
			return -1;
		}
		nag("Dropped permissions to group %s (GID %d) from GID %d\n",groupname,gid,oldgid);
	}
	if(username){
		if(getpwnam_r(username,&pwent,buf,sizeof(buf),&pdb) || !pdb){
			moan("Couldn't look up username %s\n",username);
			return -1;
		}
		uid = pdb->pw_uid;
		if(setuid(uid)){
			moan("Couldn't setuid to user %d\n",uid);
			return -1;
		}
		if(getuid() != uid){
			bitch("getuid() returned %d, not %d\n",getuid(),uid);
			return -1;
		}
		if(geteuid() != uid){
			bitch("geteuid() returned %d, not %d\n",geteuid(),uid);
			return -1;
		}
		nag("Dropped permissions to user %s (UID %d) from UID %d\n",username,uid,olduid);
	}
	return 0;
}
Beispiel #12
0
static int _getgrnam_r (const char *name, struct group *grp, char *buf,
		size_t bufsiz, struct group **result)
{
	int rc;
	while (1) {
		rc = getgrnam_r (name, grp, buf, bufsiz, result);
		if (rc == EINTR)
			continue;
		if (rc != 0)
			*result = NULL;
		break;
	}
	return (rc);
}
Beispiel #13
0
extern "C" struct group *getgrnam(const char *name)
{
  static __thread char buf[4096 * 4];
  static __thread struct group grp;
  static __thread struct group *result;

  ok_to_log_next_func = true;
  int res = getgrnam_r(name, &grp, buf, sizeof(buf), &result);

  if (res == 0) {
    return &grp;
  }

  return NULL;
}
Beispiel #14
0
static inline gid_t get_gid_by_name(const char* group_name)
{
	if (!group_name)
		writeLog(WARNING, "group_name is NULL");
	long buflen=sysconf(_SC_GETGR_R_SIZE_MAX);
	if (buflen == -1)
		die("sysconf(_SC_GETGR_R_SIZE_MAX) failed");
	char* buf=malloc(buflen);
	struct group grbuf, *grbufp;
	getgrnam_r(group_name, &grbuf, buf, buflen, &grbufp);
	free(buf);
	if(grbufp == NULL)
		writeLog(WARNING, "gid=%d can't get gid", grbufp->gr_gid);
	return grbufp->gr_gid;
}
Beispiel #15
0
static TACommandVerdict getgrnam_r_cmd(TAThread thread,TAInputStream stream)
{
    int res;
    char* name;
    struct group *grp;
    char *buffer;
    size_t bufsize;
    struct group *result;
    int i=0;
    
    name = readString(&stream);
    grp = (struct group *)readPointer(&stream);
    bufsize = readSize(&stream);
    buffer=(char *) ta_alloc_memory(bufsize*sizeof(char));
    
    errno = 0;

    START_TARGET_OPERATION_WHICH_MAY_CONTAIN_CANCELPOINT(thread);
    res = getgrnam_r(name, grp, buffer, bufsize, &result); 
    
    END_TARGET_OPERATION_WHICH_MAY_CONTAIN_CANCELPOINT(thread);
    
    writeInt(thread, res);
    writeInt(thread,errno);
    writePointer(thread,(void*)result);
    
    if(result)
    {
        writeString(thread, result->gr_name);
        writeInt(thread, result->gr_gid);
        while ((result->gr_mem)[i]!=NULL)
        {
            i++;
        }
        writeInt(thread, i);
        i=0;
        while ((result->gr_mem)[i]!=NULL)
        {
            writeString(thread, (result->gr_mem)[i]);
            i++;
        }
    } 
    
    
    sendResponse(thread);
    ta_dealloc_memory(buffer);
    return taDefaultVerdict;
}
Beispiel #16
0
TError GroupId(const std::string &group, gid_t &gid) {
    struct group grp, *ptr;
    char buf[GrpBufSize];
    int id;

    if (isdigit(group[0]) && !StringToInt(group, id) && id >= 0) {
        gid = id;
        return TError::Success();
    }

    if (getgrnam_r(group.c_str(), &grp, buf, GrpBufSize, &ptr) || !ptr)
        return TError(EError::InvalidValue, errno, "Cannot find group: " + group);

    gid = grp.gr_gid;
    return TError::Success();
}
Beispiel #17
0
uintptr_t
REG_POLY_FUN_HDR(sml_getgrnam, uintptr_t triple, Region memberListR, Region memberR, String nameML, size_t s, uintptr_t exn)
{
    uintptr_t res;
    uintptr_t *list, *pair;
    char *b;
    struct group gbuf, *gbuf2;
    char  **members;
    char *name = &(nameML->data);
    mkTagTripleML(triple);
    s = convertIntToC(s) + 1;
    b = (char *) malloc(s);
    if (!b)
    {
        res = errno;
        third(triple) = res;
        return triple;
    }
    res = getgrnam_r(name, &gbuf, b, s-1, &gbuf2);
    third(triple) = res;
    if (res)
    {
        free(b);
        return triple;
    }
    if (!gbuf2)
    {
        free(b);
        raise_exn(exn);
    }
    first(triple) = convertIntToML(gbuf2->gr_gid);
    members = gbuf2->gr_mem;
    makeNIL(list);
    while (*members)
    {
        allocPairML(memberListR, pair);
        first(pair) = (uintptr_t) REG_POLY_CALL(convertStringToML, memberR, *members);
        second(pair) = (uintptr_t) list;
        makeCONS(pair, list);
        members++;
    }
    free(b);
    second(triple) = (uintptr_t) list;
    return triple;
}
Beispiel #18
0
/**
 * @brief Return gid given a group name
 *
 * @param[in]  name  group name
 * @param[out] gid   address for gid to be filled in
 *
 * @return 0 on success and errno on failure.
 *
 * NOTE: If a group name doesn't exist, getgrnam_r returns 0 with the
 * result pointer set to NULL. We turn that into ENOENT error! Also,
 * getgrnam_r fails with ERANGE if there is a group with a large number
 * of users that it can't fill all those users into the supplied buffer.
 * This need not be the group we are asking for! ERANGE is handled here,
 * so this function never ends up returning ERANGE back to the caller.
 */
static int name_to_gid(const char *name, gid_t *gid)
{
	struct group g;
	struct group *gres = NULL;
	char *buf;
	size_t buflen = sysconf(_SC_GETGR_R_SIZE_MAX);

	/* Upper bound on the buffer length. Just to bailout if there is
	 * a bug in getgrname_r returning ERANGE incorrectly. 64MB
	 * should be good enough for now.
	 */
	size_t maxlen = 64 * 1024 * 1024;
	int err;

	if (buflen == -1)
		buflen = PWENT_BEST_GUESS_LEN;

	do {
		buf = gsh_malloc(buflen);
		if (buf == NULL) {
			LogCrit(COMPONENT_IDMAPPER,
				"gsh_malloc failed, buflen: %zu", buflen);

			return ENOMEM;
		}

		err = getgrnam_r(name, &g, buf, buflen, &gres);
		if (err == ERANGE) {
			buflen *= 16;
			gsh_free(buf);
		}
	} while (buflen <= maxlen && err == ERANGE);

	if (err == 0) {
		if (gres == NULL)
			err = ENOENT;
		else
			*gid = gres->gr_gid;
	}

	if (err != ERANGE)
		gsh_free(buf);

	return err;
}
Beispiel #19
0
static Variant php_posix_group_to_array(int gid,
                   const String& gname = null_variant.toString()) {
  // Don't pass a gid *and* a gname to this.
  assert((gid <  0) || gname.size() == 0);

  if ((gid < 0) && (gname.size() == 0)) {
    return false;
  }

  int grbuflen = sysconf(_SC_GETGR_R_SIZE_MAX);
  if (grbuflen < 1) {
    return false;
  }

  std::unique_ptr<char[]> grbuf(new char[grbuflen]);
  struct group gr;
  struct group *retgrptr = NULL;

  // If we somehow reach this point and both gname and gid were
  // passed, then the gid values will override the gname values,
  // but it will otherwise function just fine.
  // The assert() clause above should prevent that, however.
  if ((gname.size() > 0) &&
      (getgrnam_r(gname.data(), &gr, grbuf.get(), grbuflen, &retgrptr) != 0 ||
      retgrptr == nullptr)) {
    return false;
  } else if ((gid >= 0) &&
      (getgrgid_r(gid, &gr, grbuf.get(), grbuflen, &retgrptr) != 0 ||
      retgrptr == nullptr)) {
    return false;
  }

  Array members = Array::Create();
  for (int count=0; gr.gr_mem[count] != NULL; count++) {
    members.append(String(gr.gr_mem[count], CopyString));
  }

  return make_map_array(
    s_name, String(gr.gr_name, CopyString),
    s_passwd, String(gr.gr_passwd, CopyString),
    s_members, members,
    s_gid, (int)gr.gr_gid
  );
}
Beispiel #20
0
static User*
gname2user(char *name)
{
	int i;
	User *u;
	struct group grp, *result;
	char buf[512];

	for(i=0; i<nelem(gtab); i++)
		for(u=gtab[i]; u; u=u->next)
			if(strcmp(u->name, name) == 0)
				return u;

	getgrnam_r(name, &grp, buf, sizeof(buf), &result);
	if(result == NULL)
		return nil;

	return addgroup(result);
}
Beispiel #21
0
static gid_t
get_gid_from_archive(struct archive_entry *ae)
{
	static char group_buffer[128];
	static struct group grent;
	struct group *result;
	const char *group;

	group = archive_entry_gname(ae);
	if (grent.gr_name != NULL && strcmp(group, grent.gr_name) == 0)
		goto out;
	grent.gr_name = NULL;
	if ((getgrnam_r(group, &grent, group_buffer, sizeof(group_buffer),
	    &result)) < 0)
		return (0);
	if (result == NULL)
		return (0);
out:
	return (grent.gr_gid);
}
gid_t util_lookup_group(struct udev *udev, const char *group)
{
        char *endptr;
        size_t buflen = sysconf(_SC_GETGR_R_SIZE_MAX);
        char *buf;
        struct group grbuf;
        struct group *gr;
        gid_t gid = 0;

        if (strcmp(group, "root") == 0)
                return 0;
        gid = strtoul(group, &endptr, 10);
        if (endptr[0] == '\0')
                return gid;
        buf = NULL;
        gid = 0;
        for (;;) {
                char *newbuf;

                newbuf = realloc(buf, buflen);
                if (!newbuf)
                        break;
                buf = newbuf;
                errno = getgrnam_r(group, &grbuf, buf, buflen, &gr);
                if (gr != NULL) {
                        gid = gr->gr_gid;
                } else if (errno == ERANGE) {
                        buflen *= 2;
                        continue;
                } else if (errno == 0 || errno == ENOENT || errno == ESRCH) {
                        err(udev, "specified group '%s' unknown\n", group);
                } else {
                        err(udev, "error resolving group '%s': %m\n", group);
                }
                break;
        }
        free(buf);
        return gid;
}
Beispiel #23
0
Datei: ugid.c Projekt: lb1a/avfs
int av_findgid(struct ugidcache *cache, const char *gname, int deflt)
{
    if(gname == NULL || !gname[0])
        return deflt == -1 ? cache->mygid : deflt;

    if(cache->gname == NULL || strcmp(gname, cache->gname) != 0) {
        int res;
        struct group gr;
        struct group *grres;
        char *buf = NULL;
        size_t bufsize = 0;

#ifdef HAVE_GETGRNAM_R
        do {
            bufsize += 256;
            buf = av_realloc(buf, bufsize);
            res = getgrnam_r(gname, &gr, buf, bufsize, &grres);
        } while(res == ERANGE);
#else
	grres = getgrnam(gname);
#endif

        if(grres == NULL)
            cache->gid = -1;
        else
            cache->gid = grres->gr_gid;

        av_free(cache->gname);
        cache->gname = av_strdup(gname);
#ifdef HAVE_GETGRNAM_R
        av_free(buf);
#endif
    }
 
    if(cache->gid == -1)
        return deflt == -1 ? cache->mygid : deflt;
    else
        return cache->gid;
}
Beispiel #24
0
MonoBoolean
ves_icall_System_Security_Principal_WindowsPrincipal_IsMemberOfGroupName (gpointer user, const gchar *utf8_groupname, MonoError *error)
{
	gboolean result = FALSE;

#ifdef HAVE_GRP_H

	if (utf8_groupname) {
		struct group *g = NULL;
#ifdef HAVE_GETGRNAM_R
		struct group grp;
		gchar *fbuf;
		gint32 retval;
#ifdef _SC_GETGR_R_SIZE_MAX
	 	size_t fbufsize = mono_sysconf (_SC_GETGR_R_SIZE_MAX);
#else
		size_t fbufsize = MONO_SYSCONF_DEFAULT_SIZE;
#endif
		fbuf = (gchar *)g_malloc0 (fbufsize);
		retval = getgrnam_r (utf8_groupname, &grp, fbuf, fbufsize, &g);
		result = ((retval == 0) && (g == &grp));
#else
		/* default to non thread-safe but posix compliant function */
		g = getgrnam (utf8_groupname);
		result = (g != NULL);
#endif
		if (result)
			result = IsMemberOf ((uid_t) GPOINTER_TO_INT (user), g);

#ifdef HAVE_GETGRNAM_R
		g_free (fbuf);
#endif
	}

#endif /* HAVE_GRP_H */

	return result;
}
Beispiel #25
0
/*
 * resolve the POSIX gid for the groupname
 * return 0 on success
 */
static int resolve_group_gid(const char * groupname, gid_t * gid) {
    struct group gr;
    struct group *result;
    char buf[GETGR_R_SIZE_MAX];
    size_t bufsize= GETGR_R_SIZE_MAX;
    int rc;

    if (groupname==NULL) {
        pep_log_warn("resolve_group_gid: groupname is NULL");
        return -1;
    }
    pep_log_debug("resolve_group_gid for %s",groupname);
    rc= getgrnam_r(groupname,&gr,buf,bufsize,&result);
    if (rc==0 && result!=NULL) {
        *gid= gr.gr_gid;
        pep_log_debug("resolve_group_gid: gid=%d",gr.gr_gid);
        return 0;
    }
    else {
        pep_log_error("resolve_group_gid: failed to resolve POSIX gid for %s: %s",groupname,strerror(errno));
        return -2;
    }
}
/**
 * Get the group identifier from the group name.
 *
 */
gid_t
privgid(const char *groupname)
{
    struct group grp;
    struct group* result;
    long bufsize;
    char* buf;
    gid_t gid;
    int s;

    gid = getegid();

    if (groupname) {
        bufsize = sysconf(_SC_GETGR_R_SIZE_MAX);
        if (bufsize == -1) {
            bufsize = 16384; /* should be more than enough */
        }
        buf = (char*) calloc(bufsize, sizeof(char));
        if (!buf) {
            ods_log_error("[%s] calloc failed: out of memory?", privdrop_str);
            return -1;
        }
        /* Lookup the group id in /etc/group */
        s = getgrnam_r(groupname, &grp, buf, bufsize, &result); /* LEAK */
        if (s) {
            ods_log_error("[%s] unable to get group id for %s: %s",
                privdrop_str, groupname, strerror(s));
        }
        if (result != NULL) {
            gid = grp.gr_gid;
        }
        free((void*) buf);
    } else {
        gid = -1;
    }
    return gid;
}
Beispiel #27
0
/* extract a groupname and return its gid.
 * rgerhards, 2007-07-17
 */
static rsRetVal doGetGID(uchar **pp, rsRetVal (*pSetHdlr)(void*, uid_t), void *pVal)
{
	struct group *pgBuf;
	struct group gBuf;
	DEFiRet;
	uchar szName[256];
	char stringBuf[2048];	/* I hope this is large enough... */

	assert(pp != NULL);
	assert(*pp != NULL);

	if(getSubString(pp, (char*) szName, sizeof(szName) / sizeof(uchar), ' ')  != 0) {
		errmsg.LogError(0, RS_RET_NOT_FOUND, "could not extract group name");
		ABORT_FINALIZE(RS_RET_NOT_FOUND);
	}

	getgrnam_r((char*)szName, &gBuf, stringBuf, sizeof(stringBuf), &pgBuf);

	if(pgBuf == NULL) {
		errmsg.LogError(0, RS_RET_NOT_FOUND, "ID for group '%s' could not be found or error", (char*)szName);
		iRet = RS_RET_NOT_FOUND;
	} else {
		if(pSetHdlr == NULL) {
			/* we should set value directly to var */
			*((gid_t*)pVal) = pgBuf->gr_gid;
		} else {
			/* we set value via a set function */
			CHKiRet(pSetHdlr(pVal, pgBuf->gr_gid));
		}
		dbgprintf("gid %d obtained for group '%s'\n", (int) pgBuf->gr_gid, szName);
	}

	skipWhiteSpace(pp); /* skip over any whitespace */

finalize_it:
	RETiRet;
}
Beispiel #28
0
int FileSetOwnership(CStdString filename, CStdString owner, CStdString group)
{
	int res = 0;

#ifndef WIN32
	struct group fileGroup, *fgP = NULL;
	struct passwd fileUser, *fuP = NULL;
	char infoGroupBuf[4096], infoUserBuf[4096];

	memset(infoGroupBuf, 0, sizeof(infoGroupBuf));
	memset(infoUserBuf, 0, sizeof(infoUserBuf));
	memset(&fileGroup, 0, sizeof(fileGroup));
	memset(&fileUser, 0, sizeof(fileUser));

	if(!getgrnam_r(group.c_str(), &fileGroup, infoGroupBuf, sizeof(infoGroupBuf), &fgP))
	{
		if(!getpwnam_r(owner.c_str(), &fileUser, infoUserBuf, sizeof(infoUserBuf), &fuP))
		{
			if(chown(filename.c_str(), fileUser.pw_uid, fileGroup.gr_gid))
			{
				res = -1;
			}
		}
		else
		{
			res = -1;
		}
	}
	else
	{
		res = -1;
	}
#endif

	return res;
}
Beispiel #29
0
/*
 * Functions
 */
static int us_open_socket (void)
{
	struct sockaddr_un sa;
	int status;

	sock_fd = socket (PF_UNIX, SOCK_STREAM, 0);
	if (sock_fd < 0)
	{
		char errbuf[1024];
		ERROR ("unixsock plugin: socket failed: %s",
				sstrerror (errno, errbuf, sizeof (errbuf)));
		return (-1);
	}

	memset (&sa, '\0', sizeof (sa));
	sa.sun_family = AF_UNIX;
	sstrncpy (sa.sun_path, (sock_file != NULL) ? sock_file : US_DEFAULT_PATH,
			sizeof (sa.sun_path));

	DEBUG ("unixsock plugin: socket path = %s", sa.sun_path);

	if (delete_socket)
	{
		errno = 0;
		status = unlink (sa.sun_path);
		if ((status != 0) && (errno != ENOENT))
		{
			char errbuf[1024];
			WARNING ("unixsock plugin: Deleting socket file \"%s\" failed: %s",
					sa.sun_path,
					sstrerror (errno, errbuf, sizeof (errbuf)));
		}
		else if (status == 0)
		{
			INFO ("unixsock plugin: Successfully deleted socket file \"%s\".",
					sa.sun_path);
		}
	}

	status = bind (sock_fd, (struct sockaddr *) &sa, sizeof (sa));
	if (status != 0)
	{
		char errbuf[1024];
		sstrerror (errno, errbuf, sizeof (errbuf));
		ERROR ("unixsock plugin: bind failed: %s", errbuf);
		close (sock_fd);
		sock_fd = -1;
		return (-1);
	}

	status = chmod (sa.sun_path, sock_perms);
	if (status == -1)
	{
		char errbuf[1024];
		ERROR ("unixsock plugin: chmod failed: %s",
				sstrerror (errno, errbuf, sizeof (errbuf)));
		close (sock_fd);
		sock_fd = -1;
		return (-1);
	}

	status = listen (sock_fd, 8);
	if (status != 0)
	{
		char errbuf[1024];
		ERROR ("unixsock plugin: listen failed: %s",
				sstrerror (errno, errbuf, sizeof (errbuf)));
		close (sock_fd);
		sock_fd = -1;
		return (-1);
	}

	do
	{
		char *grpname;
		struct group *g;
		struct group sg;
		char grbuf[2048];

		grpname = (sock_group != NULL) ? sock_group : COLLECTD_GRP_NAME;
		g = NULL;

		status = getgrnam_r (grpname, &sg, grbuf, sizeof (grbuf), &g);
		if (status != 0)
		{
			char errbuf[1024];
			WARNING ("unixsock plugin: getgrnam_r (%s) failed: %s", grpname,
					sstrerror (errno, errbuf, sizeof (errbuf)));
			break;
		}
		if (g == NULL)
		{
			WARNING ("unixsock plugin: No such group: `%s'",
					grpname);
			break;
		}

		if (chown ((sock_file != NULL) ? sock_file : US_DEFAULT_PATH,
					(uid_t) -1, g->gr_gid) != 0)
		{
			char errbuf[1024];
			WARNING ("unixsock plugin: chown (%s, -1, %i) failed: %s",
					(sock_file != NULL) ? sock_file : US_DEFAULT_PATH,
					(int) g->gr_gid,
					sstrerror (errno, errbuf, sizeof (errbuf)));
		}
	} while (0);

	return (0);
} /* int us_open_socket */
Beispiel #30
0
/**
 * Reads the params for change persona. Format:
 * <uid[:gid]>
 */
static RC_TYPE set_change_persona_handler(CMD_DATA *p_cmd, int current_nr, void *p_context)
{
	int s, result = RC_OK;
	char *arg, *buf, *p_gid;
	ssize_t bufsize;
	gid_t gid;
	uid_t uid;
	struct passwd pwd, *pwd_res;
	long login_len_max;
	DYN_DNS_CLIENT *p_self = (DYN_DNS_CLIENT *) p_context;

	if (p_self == NULL)
	{
		return RC_INVALID_POINTER;
	}

	/* Determine max length of a username */
	login_len_max = sysconf(_SC_LOGIN_NAME_MAX);
	if (login_len_max <= 0)
	{
		login_len_max = 32;
	}

	arg = p_cmd->argv[current_nr];
	{
		char groupname[33] = ""; /* MAX 32 chars + '\0', groupadd(8) */
		char username[login_len_max+1];
		char fmt[65]; /* Conversion string for username */

		uid = getuid();
		gid = getgid();

		p_gid = strstr(arg, ":");
		if (p_gid)
		{
			if ((strlen(p_gid + 1) > 0) &&  /* if something is present after : */
			    sscanf(p_gid + 1, "%32[a-zA-Z-]", groupname) != 1)
			{
				return RC_DYNDNS_INVALID_OPTION;
			}
		}

		snprintf(fmt, sizeof(fmt), "%%%ld[a-zA-Z-]", login_len_max);
		if (sscanf(arg, fmt, username) != 1)
		{
			return RC_DYNDNS_INVALID_OPTION;
		}

		/* Get uid and gid by their names */
		if (strlen(groupname) > 0)
		{
			struct group grp;
			struct group *grp_res;

			bufsize = sysconf(_SC_GETGR_R_SIZE_MAX);
			if (bufsize == -1)
			{
				bufsize = 16384;        /* Should be more than enough */
			}

			buf = malloc(bufsize);
			if (buf == NULL)
			{
				return RC_OUT_OF_MEMORY;
			}

			s = getgrnam_r(groupname, &grp, buf, bufsize, &grp_res);
			if (grp_res != NULL)
			{
				gid = grp.gr_gid;
			}
			else
			{
				if (s == 0)
				{
					logit(LOG_ERR, MODULE_TAG "Cannot find GROUP %s", groupname);
					result = RC_OS_INVALID_GID;
				}
				else
				{
					result = RC_ERROR;
				}
			}
			free(buf);

			if (RC_OK != result)
			{
				return result;
			}
		}

		bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
		if (bufsize == -1)          /* Value was indeterminate */
		{
			bufsize = 16384;        /* Should be more than enough */
		}

		buf = malloc(bufsize);
		if (buf == NULL)
		{
			return RC_OUT_OF_MEMORY;
		}

		s = getpwnam_r(username, &pwd, buf, bufsize, &pwd_res);
		if (pwd_res != NULL)
		{
			uid = pwd.pw_uid;
			if (gid == getgid())
			{
				gid = pwd.pw_gid;
			}
		}
		else
		{
			if (s == 0)
			{
				logit(LOG_ERR, MODULE_TAG "Cannot find USER %s", username);
				result = RC_OS_INVALID_UID;
			}
			else
			{
				result = RC_ERROR;
			}
		}
		free(buf);

		if (RC_OK != result)
		{
			return result;
		}

		p_self->change_persona = TRUE;
		p_self->sys_usr_info.gid = gid;
		p_self->sys_usr_info.uid = uid;
	}

	return RC_OK;
}