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);
}
