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; }
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; }
/* 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; }
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; }
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; }
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); }
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; }
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; }
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; }
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); }
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; }
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; }
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; }
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(); }
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; }
/** * @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; }
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 ); }
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); }
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; }
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; }
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; }
/* * 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; }
/* 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; }
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; }
/* * 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 */
/** * 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; }