static bool drop_privileges(void) { bool success = false; struct passwd pwd; struct passwd* result = 0; char buf[GETPWNAM_BUFLEN]; memset(&buf, 0, sizeof buf); (void)getpwnam_r("user", &pwd, buf, GETPWNAM_BUFLEN, &result); if (!result) { (void)getpwnam_r("nobody", &pwd, buf, GETPWNAM_BUFLEN, &result); } if (!result) { debuglog("tempreaper: unable to retrieve passwd entry"); goto out; } if (setgid(pwd.pw_gid) != 0) { debuglog("tempreaper: setgid() failed with pw_gid %i (%m)", pwd.pw_gid); goto out; } if (setuid(pwd.pw_uid) != 0) { debuglog("tempreaper: setuid() failed with pw_uid %i (%m)", pwd.pw_uid); goto out; } success = true; out: return success; }
struct passwd *getpwnam_wrapper( char **user_buffer, /* getpwnam_r uses a buffer which must be freed later. This is a pointer to that buffer */ const char *user_name) { struct passwd *pwent; char *buf; long bufsize; struct passwd *result; int rc; *user_buffer = NULL; bufsize = sysconf(_SC_GETPW_R_SIZE_MAX); if (bufsize == -1) bufsize = 8196; buf = (char *)malloc(bufsize); if (buf == NULL) { log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, __func__, "failed to allocate memory"); return(NULL); } pwent = (struct passwd *)calloc(1, sizeof(struct passwd)); if (pwent == NULL) { log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, __func__, "could not allocate passwd structure"); free(buf); return(NULL); } rc = getpwnam_r(user_name, pwent, buf, bufsize, &result); if ((rc != 0) && (errno == ERANGE)) { do { free(buf); bufsize *= 2; buf = (char *)calloc(1, bufsize); rc = getpwnam_r(user_name, pwent, buf, bufsize, &result); }while((rc != 0) && (errno == ERANGE)); } else if ((rc) || (result == NULL)) { sprintf(buf, "getpwnam_r failed: %d", rc); log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, __func__, buf); free(buf); free(pwent); return (NULL); } *user_buffer = buf; return(pwent); }
// Get home directory for a given user FXString FXSystem::getUserDirectory(const FXString& user){ #ifndef WIN32 #if defined(FOX_THREAD_SAFE) && !defined(__FreeBSD__) && !defined(__OpenBSD__) struct passwd pwdresult,*pwd; char buffer[1024]; if(user.empty()){ register const FXchar* str; if((str=getenv("HOME"))!=NULL) return str; if((str=getenv("USER"))!=NULL || (str=getenv("LOGNAME"))!=NULL){ if(getpwnam_r(str,&pwdresult,buffer,sizeof(buffer),&pwd)==0 && pwd) return pwd->pw_dir; } if(getpwuid_r(getuid(),&pwdresult,buffer,sizeof(buffer),&pwd)==0 && pwd) return pwd->pw_dir; return PATHSEPSTRING; } if(getpwnam_r(user.text(),&pwdresult,buffer,sizeof(buffer),&pwd)==0 && pwd) return pwd->pw_dir; return PATHSEPSTRING; #else register struct passwd *pwd; if(user.empty()){ register const FXchar* str; if((str=getenv("HOME"))!=NULL) return str; if((str=getenv("USER"))!=NULL || (str=getenv("LOGNAME"))!=NULL){ if((pwd=getpwnam(str))!=NULL) return pwd->pw_dir; } if((pwd=getpwuid(getuid()))!=NULL) return pwd->pw_dir; return PATHSEPSTRING; } if((pwd=getpwnam(user.text()))!=NULL) return pwd->pw_dir; return PATHSEPSTRING; #endif #else if(user.empty()){ register const FXchar *str1,*str2; FXchar home[MAXPATHLEN]; DWORD size=MAXPATHLEN; HKEY hKey; LONG result; if((str1=getenv("USERPROFILE"))!=NULL) return str1; // Daniël Hörchner <*****@*****.**> if((str1=getenv("HOME"))!=NULL) return str1; if((str2=getenv("HOMEPATH"))!=NULL){ // This should be good for WinNT, Win2K according to MSDN if((str1=getenv("HOMEDRIVE"))==NULL) str1="c:"; strncpy(home,str1,MAXPATHLEN); strncat(home,str2,MAXPATHLEN); return home; } // FXchar buffer[MAX_PATH] // if(SHGetFolderPath(NULL,CSIDL_PERSONAL|CSIDL_FLAG_CREATE,NULL,O,buffer)==S_OK){ // return buffer; // } if(RegOpenKeyExA(HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders",0,KEY_READ,&hKey)==ERROR_SUCCESS){ result=RegQueryValueExA(hKey,"Personal",NULL,NULL,(LPBYTE)home,&size); // Change "Personal" to "Desktop" if you want... RegCloseKey(hKey); if(result==ERROR_SUCCESS) return home; } return "c:" PATHSEPSTRING; } return "c:" PATHSEPSTRING; #endif }
/* * does tilde expansion of strings of type ``~user/foo'' * if ``user'' isn't valid user name or ``txt'' doesn't start * w/ '~', returns pointer to strdup()ed copy of ``txt'' * * it's callers's responsibility to free() returned string */ char * fn_tilde_expand(const char *txt) { struct passwd pwres, *pass; char *temp; size_t len = 0; char pwbuf[1024]; if (txt[0] != '~') return (strdup(txt)); temp = strchr(txt + 1, '/'); if (temp == NULL) { temp = strdup(txt + 1); if (temp == NULL) return NULL; } else { len = temp - txt + 1; /* text until string after slash */ temp = malloc(len); if (temp == NULL) return NULL; (void)strncpy(temp, txt + 1, len - 2); temp[len - 2] = '\0'; } if (temp[0] == 0) { #ifdef HAVE_GETPW_R_POSIX if (getpwuid_r(getuid(), &pwres, pwbuf, sizeof(pwbuf), &pass) != 0) pass = NULL; #elif HAVE_GETPW_R_DRAFT pass = getpwuid_r(getuid(), &pwres, pwbuf, sizeof(pwbuf)); #else pass = getpwuid(getuid()); #endif } else { #ifdef HAVE_GETPW_R_POSIX if (getpwnam_r(temp, &pwres, pwbuf, sizeof(pwbuf), &pass) != 0) pass = NULL; #elif HAVE_GETPW_R_DRAFT pass = getpwnam_r(temp, &pwres, pwbuf, sizeof(pwbuf)); #else pass = getpwnam(temp); #endif } free(temp); /* value no more needed */ if (pass == NULL) return (strdup(txt)); /* update pointer txt to point at string immedially following */ /* first slash */ txt += len; temp = malloc(strlen(pass->pw_dir) + 1 + strlen(txt) + 1); if (temp == NULL) return NULL; (void)sprintf(temp, "%s/%s", pass->pw_dir, txt); return (temp); }
static struct passwd * __getpwnam_r(const char *user, struct passwd *pw, char *buf, size_t len) { #ifdef HAVE_GETPWNAM_R_POSIX struct passwd *r; if(0 == getpwnam_r(user, pw, buf, len, &r)) return r; return NULL; #else #if HAVE_GETPWNAM_R return getpwnam_r(user, pw, buf, len); #else return getpwnam(user); #endif #endif }
long REG_POLY_FUN_HDR(sml_getpwnam, long tuple, Region homeR, Region shellR, String nameML, long s, long exn) { long res; char *b; struct passwd pbuf, *pbuf2; char *name = &(nameML->data); mkTagRecordML(tuple,5); s = convertIntToC(s) + 1; b = (char *) malloc(s); if (!b) { res = errno; elemRecordML(tuple,4) = res; return tuple; } res = getpwnam_r(name, &pbuf, b, s-1, &pbuf2); elemRecordML(tuple,4) = res; if (res) { free(b); return tuple; } if (!pbuf2) { free(b); raise_exn(exn); } elemRecordML(tuple,0) = (long) pbuf2->pw_uid; elemRecordML(tuple,1) = (long) pbuf2->pw_gid; elemRecordML(tuple,2) = (long) REG_POLY_CALL(convertStringToML, homeR, pbuf2->pw_dir); elemRecordML(tuple,3) = (long) REG_POLY_CALL(convertStringToML, shellR, pbuf2->pw_shell); free(b); return tuple; }
/** Lookup NSS database for group name by specified user name. On sucess user_group returned, otherwise NULL */ char *lookup_user_group (const char *user_name, char *user_group, int user_group_len) { struct passwd pwd, *pwd_result; struct group grp, *grp_result; char *buf; int error; buf= malloc(max_nss_name_len); if (buf == NULL) return NULL; error= getpwnam_r(user_name, &pwd, buf, max_nss_name_len, &pwd_result); if (error != 0 || pwd_result == NULL) { free(buf); return NULL; } error= getgrgid_r(pwd_result->pw_gid, &grp, buf, max_nss_name_len, &grp_result); if (error != 0 || grp_result == NULL) { free(buf); return NULL; } strncpy(user_group, grp_result->gr_name, user_group_len); user_group[user_group_len]= '\0'; free(buf); return user_group; }
static int mp_gid_handler(vector strvec) { gid_t gid; char *buff; char passwd_buf[1024]; struct passwd info, *found; struct mpentry *mpe = VECTOR_LAST_SLOT(conf->mptable); if (!mpe) return 1; buff = set_value(strvec); if (!buff) return 1; if (getpwnam_r(buff, &info, passwd_buf, 1024, &found) == 0 && found) { mpe->attribute_flags |= (1 << ATTR_GID); mpe->gid = info.pw_gid; } else if (sscanf(buff, "%u", &gid) == 1) { mpe->attribute_flags |= (1 << ATTR_GID); mpe->gid = gid; } FREE(buff); return 0; }
struct passwd *lub_db_getpwnam(const char *name) { long int size; char *buf; struct passwd *pwbuf; struct passwd *pw = NULL; int res = 0; #ifdef _SC_GETPW_R_SIZE_MAX if ((size = sysconf(_SC_GETPW_R_SIZE_MAX)) < 0) size = DEFAULT_GETPW_R_SIZE_MAX; #else size = DEFAULT_GETPW_R_SIZE_MAX; #endif pwbuf = malloc(sizeof(*pwbuf) + size); if (!pwbuf) return NULL; buf = (char *)pwbuf + sizeof(*pwbuf); res = getpwnam_r(name, pwbuf, buf, size, &pw); if (res || !pw) { free(pwbuf); if (res != 0) errno = res; else errno = ENOENT; return NULL; } return pw; }
enum perf_target_errno perf_target__parse_uid(struct perf_target *target) { struct passwd pwd, *result; char buf[1024]; const char *str = target->uid_str; target->uid = UINT_MAX; if (str == NULL) return PERF_ERRNO_TARGET__SUCCESS; /* Try user name first */ getpwnam_r(str, &pwd, buf, sizeof(buf), &result); if (result == NULL) { /* * The user name not found. Maybe it's a UID number. */ char *endptr; int uid = strtol(str, &endptr, 10); if (*endptr != '\0') return PERF_ERRNO_TARGET__INVALID_UID; getpwuid_r(uid, &pwd, buf, sizeof(buf), &result); if (result == NULL) return PERF_ERRNO_TARGET__USER_NOT_FOUND; } target->uid = result->pw_uid; return PERF_ERRNO_TARGET__SUCCESS; }
struct passwd * cockpit_getpwnam_a (const gchar *user, int *errp) { int err; long bufsize = sysconf (_SC_GETPW_R_SIZE_MAX); struct passwd *ret = NULL; struct passwd *buf; g_return_val_if_fail (bufsize >= 0, NULL); buf = malloc (sizeof(struct passwd) + bufsize); if (buf == NULL) err = ENOMEM; else err = getpwnam_r (user, buf, (char *)(buf + 1), bufsize, &ret); if (ret == NULL) { free (buf); if (err == 0) err = ENOENT; } if (errp) *errp = err; return ret; }
int set_uid_name(apr_pool_t *pool, const char *user) { apr_pool_t *subpool; char *buf; struct passwd pwd, *p2; long s; apr_pool_create(&subpool, pool); s = sysconf(_SC_GETPW_R_SIZE_MAX); buf = apr_pcalloc(subpool, s); do { getpwnam_r(user, &pwd, buf, s, &p2); if (p2 == NULL) { KERROR_SET(_server_, 0, "username %s not found", user); break; } if (seteuid(pwd.pw_uid) < 0) { KERROR_SET(_server_, 0, "cannot change process username to %s", user); break; } apr_pool_destroy(subpool); return 0; } while (0); apr_pool_destroy(subpool); return -1; }
struct passwd* getpwnam(const char* username) { static struct passwd result_object; static char* buf = NULL; static size_t buflen = 0; if ( !buf ) { size_t new_buflen = 64; if ( !(buf = (char*) malloc(new_buflen)) ) return NULL; buflen = new_buflen; } struct passwd* result; int errnum; retry: errnum = getpwnam_r(username, &result_object, buf, buflen, &result); if ( errnum == ERANGE ) { size_t new_buflen = 2 * buflen; char* new_buf = (char*) realloc(buf, new_buflen); if ( !new_buf ) return NULL; buf = new_buf; buflen = new_buflen; goto retry; } if ( errnum < 0 ) return errno = errnum, (struct passwd*) NULL; return result; }
/** * Get the user identifier from the username. * */ uid_t privuid(const char* username) { struct passwd pwd; struct passwd* result; long bufsize; char* buf; uid_t uid; int s; uid = geteuid(); if (username) { bufsize = sysconf(_SC_GETPW_R_SIZE_MAX); if (bufsize == -1) { bufsize = 16384; /* should be more than enough */ } buf = (char*) calloc(bufsize, sizeof(char)); if (!buf) { ods_log_crit("[%s] calloc failed: insufficient memory", logstr); return -1; } /* Lookup the user id in /etc/passwd */ s = getpwnam_r(username, &pwd, buf, bufsize, &result); /* leaks? */ if (s) { ods_log_error("[%s] unable to get user id for %s: %s", logstr, username, strerror(s)); } if (result != NULL) { uid = pwd.pw_uid; } free(buf); } else { uid = -1; } return uid; }
int main(void){ struct passwd pwbuf, *ptr; char *buf; int len = 3000; buf=malloc(len); if(!buf){ perror("malloc"); exit(EXIT_FAILURE); } if(signal(SIGALRM, handler)==SIG_ERR){ perror("signal"); exit(EXIT_FAILURE); } alarm(1); for(;;){ if (getpwnam_r(TARGET_NAME, &pwbuf, buf, len, &ptr) != 0) { perror("getpwnam"); exit(EXIT_FAILURE); } if(strcmp(ptr->pw_name,TARGET_NAME) != 0){ printf("return value corrupted! pw_name =%s\n",ptr->pw_name); exit(EXIT_FAILURE); } } free(buf); }
static struct passwd *get_passwd_entry(const char *username, char **pwdbuf, struct passwd *pwd) { struct passwd *res = NULL; size_t sz = 16384; int x; if (!pwdbuf || !username) return NULL; #ifdef _SC_GETPW_R_SIZE_MAX { long xsz = sysconf(_SC_GETPW_R_SIZE_MAX); if (xsz > 0) sz = (size_t) xsz; } #endif *pwdbuf = xrealloc(*pwdbuf, sz); x = getpwnam_r(username, pwd, *pwdbuf, sz, &res); if (!res) { errno = x; return NULL; } return res; }
int mnt_get_uid(const char *username, uid_t *uid) { int rc = -1; struct passwd pwd; struct passwd *pw; size_t sz = get_pw_record_size(); char *buf; if (!username || !uid) return -EINVAL; buf = malloc(sz); if (!buf) return -ENOMEM; if (!getpwnam_r(username, &pwd, buf, sz, &pw) && pw) { *uid= pw->pw_uid; rc = 0; } else { DBG(UTILS, mnt_debug( "cannot convert '%s' username to UID", username)); rc = errno ? -errno : -EINVAL; } free(buf); return rc; }
static int get_uid (const char *user, uid_t *uidp) { size_t buflen = sysconf (_SC_GETPW_R_SIZE_MAX); char *buf = (char *) alloca (buflen); while (1) { struct passwd result; struct passwd *resp; int r = getpwnam_r (user, &result, buf, buflen, &resp); if (r == 0 && resp != NULL) { *uidp = resp->pw_uid; return 0; } if (r != ERANGE) break; buf = extend_alloca (buf, buflen, 2 * buflen); } return 1; }
static int get_uid(const char* name, uid_t* uid, gid_t* gid) { struct passwd pwd; struct passwd *result; char *buf; size_t buflen; if (!strcmp(name, "root")) { *uid = *gid = 0; return 0; } buflen = sysconf(_SC_GETPW_R_SIZE_MAX); if (buflen == -1) buflen = 16384; buf = alloca(buflen); if (!buf) goto fail; getpwnam_r(name, &pwd, buf, buflen, &result); if (!result) goto fail; *uid = pwd.pw_uid; *gid = pwd.pw_gid; return 0; fail: syslog(LOG_WARNING, "%s: failure in %s: %m", __FILE__, __FUNCTION__); return -1; }
enum posix_passwd_result_t posix_getpwnam (const char *name, struct posix_passwd_t *pw) /*@globals errno; @*/ /*@modifies errno; @*/ { int r; errno = 0; r = getpwnam_r (name, &pw->storage, pw->string_buffer, sizeof (pw->string_buffer), &pw->result_ptr); /* No error, user record found. */ if ((r == 0) && (pw->result_ptr != NULL)) { return POSIX_PASSWD_RESULT_OK; } /* No error, no user record found. */ if ((r == 0) && (pw->result_ptr == NULL)) { return POSIX_PASSWD_RESULT_NO_USER; } /* Error occurred. */ return POSIX_PASSWD_RESULT_ERROR; }
int drop_privileges() { if (getuid() == 0) { char stringBuf[2048]; struct passwd pwbuf; struct passwd *pwbufp = 0; struct group gbuf; struct group *gbufp = 0; if (getpwnam_r(user, &pwbuf, stringBuf, 2048, &pwbufp) != 0 || pwbufp != &pwbuf) { log_err("Failed to obtain the UID associated with the user '%s'", user); return -1; } if (getgrnam_r(group, &gbuf, stringBuf, 2048, &gbufp) != 0 || gbufp != &gbuf) { log_err("Failed to obtain the GID associated with the group '%s'", group); return -1; } uid_t uid = pwbuf.pw_uid; gid_t gid = gbuf.gr_gid; if (setgid(gid) != 0) { log_err("Failed to set the group ID"); return -1; } if (setuid(uid) != 0) { log_err("Failed to set the user ID"); return -1; } } return 0; }
int crm_user_lookup(const char *name, uid_t * uid, gid_t * gid) { int rc = pcmk_ok; char *buffer = NULL; struct passwd pwd; struct passwd *pwentry = NULL; buffer = calloc(1, PW_BUFFER_LEN); rc = getpwnam_r(name, &pwd, buffer, PW_BUFFER_LEN, &pwentry); if (pwentry) { if (uid) { *uid = pwentry->pw_uid; } if (gid) { *gid = pwentry->pw_gid; } crm_trace("User %s has uid=%d gid=%d", name, pwentry->pw_uid, pwentry->pw_gid); } else { rc = rc? -rc : -EINVAL; crm_info("User %s lookup: %s", name, pcmk_strerror(rc)); } free(buffer); return rc; }
int hadoop_user_info_fetch(struct hadoop_user_info *uinfo, const char *username) { struct passwd *pwd; int err; size_t buf_sz; char *nbuf; hadoop_user_info_clear(uinfo); for (;;) { do { pwd = NULL; err = getpwnam_r(username, &uinfo->pwd, uinfo->buf, uinfo->buf_sz, &pwd); } while ((!pwd) && (errno == EINTR)); if (pwd) { return 0; } if (err != ERANGE) { return getpwnam_error_translate(errno); } buf_sz = uinfo->buf_sz * 2; nbuf = realloc(uinfo->buf, buf_sz); if (!nbuf) { return ENOMEM; } uinfo->buf = nbuf; uinfo->buf_sz = buf_sz; } }
Boolean System::isPrivilegedUser(const String& userName) { #if defined(PEGASUS_OS_PASE) CString user = userName.getCString(); // this function only can be found in PASE environment return umeIsPrivilegedUser((const char *)user); #else struct passwd pwd; struct passwd *result; const unsigned int PWD_BUFF_SIZE = 1024; char pwdBuffer[PWD_BUFF_SIZE]; if (getpwnam_r( userName.getCString(), &pwd, pwdBuffer, PWD_BUFF_SIZE, &result) != 0) { PEG_TRACE(( TRC_OS_ABSTRACTION, Tracer::LEVEL1, "getpwnam_r failure : %s", strerror(errno))); } // Check if the requested entry was found. If not return false. if ( result != NULL ) { // Check if the uid is 0. if ( pwd.pw_gid == 0 || pwd.pw_uid == 0 ) { return true; } } return false; #endif }
int API minijail_change_user(struct minijail *j, const char *user) { char *buf = NULL; struct passwd pw; struct passwd *ppw = NULL; ssize_t sz = sysconf(_SC_GETPW_R_SIZE_MAX); if (sz == -1) sz = 65536; /* your guess is as good as mine... */ /* * sysconf(_SC_GETPW_R_SIZE_MAX), under glibc, is documented to return * the maximum needed size of the buffer, so we don't have to search. */ buf = malloc(sz); if (!buf) return -ENOMEM; getpwnam_r(user, &pw, buf, sz, &ppw); /* * We're safe to free the buffer here. The strings inside pw point * inside buf, but we don't use any of them; this leaves the pointers * dangling but it's safe. ppw points at pw if getpwnam_r succeeded. */ free(buf); /* getpwnam_r(3) does *not* set errno when |ppw| is NULL. */ if (!ppw) return -1; minijail_change_uid(j, ppw->pw_uid); j->user = strdup(user); if (!j->user) return -ENOMEM; j->usergid = ppw->pw_gid; return 0; }
int h2o_setuidgid(const char *user) { #ifndef _MSC_VER struct passwd pwbuf, *pw; char buf[65536]; /* should be large enough */ errno = 0; if (getpwnam_r(user, &pwbuf, buf, sizeof(buf), &pw) != 0) { perror("getpwnam_r"); return -1; } if (pw == NULL) { fprintf(stderr, "unknown user:%s\n", user); return -1; } if (setgid(pw->pw_gid) != 0) { fprintf(stderr, "setgid(%d) failed:%s\n", (int)pw->pw_gid, strerror(errno)); return -1; } if (initgroups(pw->pw_name, pw->pw_gid) != 0) { fprintf(stderr, "initgroups(%s, %d) failed:%s\n", pw->pw_name, (int)pw->pw_gid, strerror(errno)); return -1; } if (setuid(pw->pw_uid) != 0) { fprintf(stderr, "setuid(%d) failed:%s\n", (int)pw->pw_uid, strerror(errno)); return -1; } #else return 0; #endif }
/* Thread-safe getpwnam() function. Returned value should be freed using pa_getpwnam_free() when the caller is finished with the returned passwd data. API is the same as getpwnam(), errors are indicated by a NULL return; consult errno for the error cause (zero it before calling). */ struct passwd *pa_getpwnam_malloc(const char *name) { size_t buflen, getpw_buflen; int err; void *buf; void *getpw_buf; struct passwd *result = NULL; buflen = starting_getpw_buflen(); buf = pa_xmalloc(buflen); getpw_buflen = buflen - sizeof(struct passwd); getpw_buf = (char *)buf + sizeof(struct passwd); while ((err = getpwnam_r(name, (struct passwd *)buf, getpw_buf, getpw_buflen, &result)) == ERANGE) { if (expand_buffer_trashcontents(&buf, &buflen)) break; getpw_buflen = buflen - sizeof(struct passwd); getpw_buf = (char *)buf + sizeof(struct passwd); } if (err || !result) { result = NULL; if (buf) { pa_xfree(buf); buf = NULL; } } pa_assert(result == buf || result == NULL); return result; }
char* girara_get_home_directory(const char* user) { if (user == NULL || g_strcmp0(user, g_get_user_name()) == 0) { return g_strdup(g_get_home_dir()); } // XXX: The following code is very unportable. struct passwd pwd; struct passwd* result = NULL; #ifdef _SC_GETPW_R_SIZE_MAX int bufsize = sysconf(_SC_GETPW_R_SIZE_MAX); if (bufsize < 0) { bufsize = 4096; } #else int bufsize = 4096; #endif char* buffer = g_try_malloc0(sizeof(char) * bufsize); if (buffer == NULL) { return NULL; } getpwnam_r(user, &pwd, buffer, bufsize, &result); if (result == NULL) { g_free(buffer); return NULL; } char* dir = g_strdup(pwd.pw_dir); g_free(buffer); return dir; }
void Cronolog::changeOwner(const string &username, const string &symlink) { if (username.empty() || symlink.empty()) { return; } int username_length = sysconf(_SC_GETPW_R_SIZE_MAX); if (username_length == -1) { username_length = 512; } struct passwd user_info, *user_infop; std::vector<char> username_buf(username_length); if (getpwnam_r(username.c_str(), &user_info, &username_buf[0], username_length, &user_infop)) { // invalid user return; } if (lchown(symlink.c_str(), user_info.pw_uid, -1) < 0) { fprintf(stderr, "Unable to chmod %s\n", symlink.c_str()); } // using chown() isn't portable if it is a symlink int fd = open(symlink.c_str(), O_RDONLY | O_NONBLOCK | O_NOCTTY); int success = (fd >= 0 ? fchown(fd, user_info.pw_uid, -1) : -1); if (fd >= 0) { close(fd); } if (success < 0) { fprintf(stderr, "Unable to chmod %s\n", symlink.c_str()); } }
int main(int argc, char *argv[]) { struct passwd pwd; struct passwd *result; char *buf; size_t bufSize; int s; if (argc != 2 || strcmp(argv[1], "--help") == 0) usageErr("%s username\n", argv[0]); bufSize = sysconf(_SC_GETPW_R_SIZE_MAX); buf = malloc(bufSize); if (buf == NULL) errExit("malloc %d", bufSize); s = getpwnam_r(argv[1], &pwd, buf, bufSize, &result); if (s != 0) errExitEN(s, "getpwnam_r"); if (result != NULL) printf("Name: %s\n", pwd.pw_gecos); else printf("Not found\n"); exit(EXIT_SUCCESS); }