void sql_write(const char* path,const char* op)
{
memset(&logg,0,sizeof(logg));
++id;
logg.logg_id=id;
get_timestamp(0,logg.time);
strncpy(logg.operation,op,32);
// REMEMBER: path my be non existing //
char *absolute_path;
char *relative_path;
absolute_path=get_abs_path(path);
relative_path=get_rel_path(path);
strncpy(logg.file,absolute_path,1024);
struct stat stbuf;
if(lstat(relative_path,&stbuf)==0)
{
logg.protection=(unsigned int)stbuf.st_mode;
uid_t uid;
uid=stbuf.st_uid;
size_t buflen;
buflen=sysconf(_SC_GETPW_R_SIZE_MAX);
if(buflen==-1) exit(EXIT_FAILURE);
char *buf;
buf=malloc(buflen);
if(!buf) exit(EXIT_FAILURE);
struct passwd pwd;
struct passwd *pwd_result;
if(getpwuid_r(uid,&pwd,buf,buflen,&pwd_result)==0)
{
if(pwd_result) strncpy(logg.owner,pwd.pw_name,256);
}
free(buf);
gid_t gid;
gid=stbuf.st_gid;
buflen=sysconf(_SC_GETGR_R_SIZE_MAX);
if(buflen==-1) exit(EXIT_FAILURE);
buf=malloc(buflen);
if(!buf) exit(EXIT_FAILURE);
struct group grp;
struct group *grp_result;
if(getgrgid_r(gid,&grp,buf,buflen,&grp_result)==0)
{
if(grp_result) strncpy(logg.group,grp.gr_name,256);
}
free(buf);
}
free(absolute_path);
free(relative_path);
strncpy(logg.host,conf.hostname,256);
strncpy(logg.tag,conf.tagname,64);
logg.uid=(unsigned int)fuse_get_context()->uid;
logg.gid=(unsigned int)fuse_get_context()->gid;
logg.pid=(unsigned int)fuse_get_context()->pid;
if(conf.log_username)
{
uid_t uid;
uid=fuse_get_context()->uid;
size_t buflen;
buflen=sysconf(_SC_GETPW_R_SIZE_MAX);
if(buflen==-1) exit(EXIT_FAILURE);
char *buf;
buf=malloc(buflen);
if(!buf) exit(EXIT_FAILURE);
struct passwd pwd;
struct passwd *result;
if(getpwuid_r(uid,&pwd,buf,buflen,&result)==0)
{
if(result) strncpy(logg.username,pwd.pw_name,256);
}
free(buf);
if(is_str(logg.username))
{
if(conf.log_tty||conf.log_remote_host||conf.log_login_time)
{
setutxent();
struct utmpx *utx;
while((utx=getutxent()))
{
if(!strcmp(logg.username,utx->ut_user))
{
if(conf.log_tty) strncpy(logg.tty,utx->ut_line,16);
if(conf.log_remote_host) strncpy(logg.remote_host,utx->ut_host,256);
if(conf.log_login_time) get_timestamp(utx->ut_tv.tv_sec,logg.login_time);
}
}
endutxent();
}
}
}
if(conf.log_groupname)
{
gid_t gid;
gid=fuse_get_context()->gid;
size_t buflen;
buflen=sysconf(_SC_GETGR_R_SIZE_MAX);
if(buflen==-1) exit(EXIT_FAILURE);
char *buf;
buf=malloc(buflen);
if(!buf) exit(EXIT_FAILURE);
struct group grp;
struct group *result;
if(getgrgid_r(gid,&grp,buf,buflen,&result)==0)
{
if(result) strncpy(logg.groupname,grp.gr_name,256);
}
free(buf);
}
if(conf.log_cmd)
{
size_t size;
size=strlen("/proc//cmdline")+10+1;
char *buf;
buf=malloc(size);
if(!buf) exit(EXIT_FAILURE);
if(snprintf(buf,size,"/proc/%i/cmdline",logg.pid))
{
FILE *fp;
fp=fopen(buf,"r");
free(buf);
if(!fp) return;
buf=malloc(1024);
if(!buf) exit(EXIT_FAILURE);
size_t bytes_r;
bytes_r=fread(buf,1,1024,fp);
fclose(fp);
if(bytes_r==0)
{
free(buf);
return;
}
strncpy(logg.cmd,buf,1024);
if(conf.log_args)
{
int i=0;
while(++i<bytes_r-1) if(buf[i]==0x00) buf[i]=0x20;
int str_off=strlen(logg.cmd);
strncpy(logg.args,&buf[str_off],1024);
free(buf);
}
}
}
if(conf.log_ppid)
{
size_t size;
size=strlen("/proc//status")+10+1;
char *buf;
buf=malloc(size);
if(!buf) exit(EXIT_FAILURE);
if(snprintf(buf,size,"/proc/%i/status",logg.pid))
{
FILE *fp;
fp=fopen(buf,"r");
free(buf);
if(!fp) return;
char *line=NULL;
size_t len=0;
while(getline(&line,&len,fp)!=-1)
{
if(!strncmp(line,"PPid:",5))
{
if((strlen(line)-6)<20) sscanf(line,"PPid:\t%i",&logg.ppid);
break;
}
}
fclose(fp);
free(line);
}
if(conf.log_ppid_cmd)
{
size_t size;
size=strlen("/proc//cmdline")+10+1;
char *buf;
buf=malloc(size);
if(!buf) exit(EXIT_FAILURE);
if(snprintf(buf,size,"/proc/%i/cmdline",logg.ppid))
{
FILE *fp;
fp=fopen(buf,"r");
free(buf);
if(!fp) return;
buf=malloc(1024);
if(!buf) exit(EXIT_FAILURE);
size_t bytes_r;
bytes_r=fread(buf,1,1024,fp);
fclose(fp);
if(bytes_r==0)
{
free(buf);
return;
}
strncpy(logg.p_cmd,buf,1024);
free(buf);
}
}
}
size_t size;
size=strlen(INS)
+strlen(conf.db_database)
+strlen(conf.db_table)
+20
+strlen(logg.time)
+strlen(logg.host)
+strlen(logg.tag)
+strlen(logg.operation)
+10
+10
+strlen(logg.username)
+strlen(logg.groupname)
+strlen(logg.tty)
+strlen(logg.login_time)
+strlen(logg.remote_host)
+strlen(logg.cmd)
+strlen(logg.args)
+10
+10
+strlen(logg.p_cmd)
+strlen(logg.file)
+10
+strlen(logg.owner)
+strlen(logg.group);
char *buf;
buf=malloc(size);
if(!buf) exit(EXIT_FAILURE);
if((size=snprintf(buf,size,
INS,
conf.db_database,
conf.db_table,
logg.logg_id,
logg.time,
logg.host,
logg.tag,
logg.operation,
logg.uid,
logg.gid,
logg.username,
logg.groupname,
logg.tty,
logg.login_time,
logg.remote_host,
logg.cmd,
logg.args,
logg.pid,
logg.ppid,
logg.p_cmd,
logg.file,
logg.protection,
logg.owner,
logg.group))) {
if(mysql_real_query(conn,buf,size)) sql_err(conn,buf);
}
free(buf);
}
static bool xdr_encode_nfs4_princ(XDR *xdrs, uint32_t id, bool group)
{
const struct gsh_buffdesc *found;
uint32_t not_a_size_t;
bool success = false;
PTHREAD_RWLOCK_rdlock(group ? &idmapper_group_lock :
&idmapper_user_lock);
if (group)
success = idmapper_lookup_by_gid(id, &found);
else
success = idmapper_lookup_by_uid(id, &found, NULL);
if (likely(success)) {
not_a_size_t = found->len;
/* Fully qualified owners are always stored in the
hash table, no matter what our lookup method. */
success =
inline_xdr_bytes(xdrs, (char **)&found->addr, ¬_a_size_t,
UINT32_MAX);
PTHREAD_RWLOCK_unlock(group ? &idmapper_group_lock :
&idmapper_user_lock);
return success;
} else {
PTHREAD_RWLOCK_unlock(group ? &idmapper_group_lock :
&idmapper_user_lock);
int rc;
int size;
bool looked_up = false;
char *namebuff = NULL;
struct gsh_buffdesc new_name;
if (nfs_param.nfsv4_param.use_getpwnam) {
if (group)
size = sysconf(_SC_GETGR_R_SIZE_MAX);
else
size = sysconf(_SC_GETPW_R_SIZE_MAX);
if (size == -1)
size = PWENT_BEST_GUESS_LEN;
new_name.len = size;
size += owner_domain.len + 2;
} else {
size = NFS4_MAX_DOMAIN_LEN + 2;
}
namebuff = alloca(size);
new_name.addr = namebuff;
if (nfs_param.nfsv4_param.use_getpwnam) {
char *cursor;
bool nulled;
if (group) {
struct group g;
struct group *gres;
rc = getgrgid_r(id, &g, namebuff, new_name.len,
&gres);
nulled = (gres == NULL);
} else {
struct passwd p;
struct passwd *pres;
rc = getpwuid_r(id, &p, namebuff, new_name.len,
&pres);
nulled = (pres == NULL);
}
if ((rc == 0) && !nulled) {
new_name.len = strlen(namebuff);
cursor = namebuff + new_name.len;
*(cursor++) = '@';
++new_name.len;
memcpy(cursor, owner_domain.addr,
owner_domain.len);
new_name.len += owner_domain.len;
looked_up = true;
} else {
LogInfo(COMPONENT_IDMAPPER,
"%s failed with code %d.",
(group ? "getgrgid_r" : "getpwuid_r"),
rc);
}
} else {
#ifdef USE_NFSIDMAP
if (group) {
rc = nfs4_gid_to_name(id, owner_domain.addr,
namebuff,
NFS4_MAX_DOMAIN_LEN + 1);
} else {
rc = nfs4_uid_to_name(id, owner_domain.addr,
namebuff,
NFS4_MAX_DOMAIN_LEN + 1);
}
if (rc == 0) {
new_name.len = strlen(namebuff);
looked_up = true;
} else {
LogInfo(COMPONENT_IDMAPPER,
"%s failed with code %d.",
(group ? "nfs4_gid_to_name" :
"nfs4_uid_to_name"), rc);
}
#else /* USE_NFSIDMAP */
looked_up = false;
#endif /* !USE_NFSIDMAP */
}
if (!looked_up) {
if (nfs_param.nfsv4_param.allow_numeric_owners) {
LogInfo(COMPONENT_IDMAPPER,
"Lookup for %d failed, using numeric %s",
id, (group ? "group" : "owner"));
/* 2**32 is 10 digits long in decimal */
sprintf(namebuff, "%u", id);
new_name.len = strlen(namebuff);
} else {
LogInfo(COMPONENT_IDMAPPER,
"Lookup for %d failed, using nobody.",
id);
memcpy(new_name.addr, "nobody", 6);
new_name.len = 6;
}
}
/* Add to the cache and encode the result. */
PTHREAD_RWLOCK_wrlock(group ? &idmapper_group_lock :
&idmapper_user_lock);
if (group)
success = idmapper_add_group(&new_name, id);
else
success = idmapper_add_user(&new_name, id, NULL, false);
PTHREAD_RWLOCK_unlock(group ? &idmapper_group_lock :
&idmapper_user_lock);
if (unlikely(!success)) {
LogMajor(COMPONENT_IDMAPPER, "%s failed.",
group ? "idmapper_add_group" :
"idmaper_add_user");
}
not_a_size_t = new_name.len;
return inline_xdr_bytes(xdrs, (char **)&new_name.addr,
¬_a_size_t, UINT32_MAX);
}
}
dpl_status_t
dpl_posix_get_metadatum_from_value(const char *key,
dpl_value_t *val,
dpl_metadatum_func_t metadatum_func,
void *cb_arg,
dpl_dict_t *metadata,
dpl_sysmd_t *sysmdp)
{
dpl_status_t ret, ret2;
int iret;
char buf[256];
struct metadata_conven mc = { .metadata=metadata, .sysmdp=sysmdp };
if (sysmdp)
{
if (!strcmp(key, "atime"))
{
assert(val->type == DPL_VALUE_STRING);
sysmdp->atime = strtoul(dpl_sbuf_get_str(val->string), NULL, 0);
sysmdp->mask |= DPL_SYSMD_MASK_ATIME;
}
else if (!strcmp(key, "mtime"))
{
assert(val->type == DPL_VALUE_STRING);
sysmdp->mtime = strtoul(dpl_sbuf_get_str(val->string), NULL, 0);
sysmdp->mask |= DPL_SYSMD_MASK_MTIME;
}
else if (!strcmp(key, "ctime"))
{
assert(val->type == DPL_VALUE_STRING);
sysmdp->ctime = strtoul(dpl_sbuf_get_str(val->string), NULL, 0);
sysmdp->mask |= DPL_SYSMD_MASK_CTIME;
}
else if (!strcmp(key, "size"))
{
assert(val->type == DPL_VALUE_STRING);
sysmdp->size = strtoul(dpl_sbuf_get_str(val->string), NULL, 0);
sysmdp->mask |= DPL_SYSMD_MASK_SIZE;
}
else if (!strcmp(key, "uid"))
{
uid_t uid;
struct passwd pwd, *pwdp;
assert(val->type == DPL_VALUE_STRING);
uid = atoi(dpl_sbuf_get_str(val->string));
iret = getpwuid_r(uid, &pwd, buf, sizeof (buf), &pwdp);
if (iret == -1)
{
perror("getpwuid");
ret = DPL_FAILURE;
goto end;
}
snprintf(sysmdp->owner, sizeof (sysmdp->owner), "%s", pwdp->pw_name);
sysmdp->mask |= DPL_SYSMD_MASK_OWNER;
}
else if (!strcmp(key, "gid"))
{
gid_t gid;
struct group grp, *grpp;
assert(val->type == DPL_VALUE_STRING);
gid = atoi(dpl_sbuf_get_str(val->string));
iret = getgrgid_r(gid, &grp, buf, sizeof (buf), &grpp);
if (iret == -1)
{
perror("getgrgid");
ret = DPL_FAILURE;
goto end;
}
snprintf(sysmdp->group, sizeof (sysmdp->group), "%s", grpp->gr_name);
sysmdp->mask |= DPL_SYSMD_MASK_GROUP;
}
else if (!strcmp(key, "ino"))
{
assert(val->type == DPL_VALUE_STRING);
snprintf(sysmdp->id, sizeof (sysmdp->id), "%s",
dpl_sbuf_get_str(val->string));
sysmdp->mask |= DPL_SYSMD_MASK_ID;
}
}
if (!strcmp(key, "xattr"))
{
//this is the metadata object
if (DPL_VALUE_SUBDICT != val->type)
{
ret = DPL_EINVAL;
goto end;
}
if (metadata)
{
if (metadatum_func)
{
ret2 = metadatum_func(cb_arg, key, val);
if (DPL_SUCCESS != ret2)
{
ret = ret2;
goto end;
}
}
//add xattr's md into metadata
ret2 = dpl_dict_iterate(val->subdict,
cb_posix_get_metadatum_from_xattr_value,
&mc);
if (DPL_SUCCESS != ret2)
{
ret = ret2;
goto end;
}
}
}
ret = DPL_SUCCESS;
end:
return ret;
}
int handle_request(struct ipa_extdom_ctx *ctx, struct extdom_req *req,
struct extdom_res **res)
{
int ret;
char *domain_name = NULL;
char *sid_str = NULL;
size_t buf_len;
char *buf = NULL;
long pw_max;
long gr_max;
struct pwd_grp pg_data;
struct passwd *pwd_result = NULL;
struct group *grp_result = NULL;
enum sss_id_type id_type;
char *fq_name = NULL;
char *sep;
pw_max = sysconf(_SC_GETPW_R_SIZE_MAX);
gr_max = sysconf(_SC_GETGR_R_SIZE_MAX);
if (pw_max == -1 && gr_max == -1) {
buf_len = 16384;
} else {
buf_len = MAX(pw_max, gr_max);
}
buf = malloc(sizeof(char) * buf_len);
if (buf == NULL) {
return LDAP_OPERATIONS_ERROR;
}
switch (req->input_type) {
case INP_POSIX_UID:
if (req->request_type == REQ_SIMPLE) {
ret = sss_nss_getsidbyid(req->data.posix_uid.uid, &sid_str,
&id_type);
} else {
id_type = SSS_ID_TYPE_UID;
ret = getpwuid_r(req->data.posix_uid.uid, &pg_data.data.pwd, buf,
buf_len, &pwd_result);
}
domain_name = strdup(req->data.posix_uid.domain_name);
break;
case INP_POSIX_GID:
if (req->request_type == REQ_SIMPLE) {
ret = sss_nss_getsidbyid(req->data.posix_uid.uid, &sid_str,
&id_type);
} else {
id_type = SSS_ID_TYPE_GID;
ret = getgrgid_r(req->data.posix_gid.gid, &pg_data.data.grp, buf,
buf_len, &grp_result);
}
domain_name = strdup(req->data.posix_gid.domain_name);
break;
case INP_SID:
ret = sss_nss_getnamebysid(req->data.sid, &fq_name, &id_type);
if (ret != 0) {
ret = LDAP_OPERATIONS_ERROR;
goto done;
}
sep = strrchr(fq_name, SSSD_DOMAIN_SEPARATOR);
if (sep == NULL) {
ret = LDAP_OPERATIONS_ERROR;
goto done;
}
ret = asprintf(&domain_name, "%s", sep+1);
if (ret == -1) {
ret = LDAP_OPERATIONS_ERROR;
domain_name = NULL; /* content is undefined according to
asprintf(3) */
goto done;
}
switch(id_type) {
case SSS_ID_TYPE_UID:
case SSS_ID_TYPE_BOTH:
ret = getpwnam_r(fq_name, &pg_data.data.pwd, buf, buf_len,
&pwd_result);
break;
case SSS_ID_TYPE_GID:
ret = getgrnam_r(fq_name, &pg_data.data.grp, buf, buf_len,
&grp_result);
break;
default:
ret = LDAP_OPERATIONS_ERROR;
goto done;
}
break;
case INP_NAME:
ret = asprintf(&fq_name, "%s%c%s", req->data.name.object_name,
SSSD_DOMAIN_SEPARATOR,
req->data.name.domain_name);
if (ret == -1) {
ret = LDAP_OPERATIONS_ERROR;
fq_name = NULL; /* content is undefined according to
asprintf(3) */
goto done;
}
if (req->request_type == REQ_SIMPLE) {
ret = sss_nss_getsidbyname(fq_name, &sid_str, &id_type);
} else {
id_type = SSS_ID_TYPE_UID;
ret = getpwnam_r(fq_name, &pg_data.data.pwd, buf, buf_len,
&pwd_result);
if (ret == 0 && pwd_result == NULL) { /* no user entry found */
id_type = SSS_ID_TYPE_GID;
ret = getgrnam_r(fq_name, &pg_data.data.grp, buf, buf_len,
&grp_result);
}
}
domain_name = strdup(req->data.name.domain_name);
break;
default:
ret = LDAP_PROTOCOL_ERROR;
goto done;
}
if (ret != 0) {
ret = LDAP_OPERATIONS_ERROR;
goto done;
} else if (ret == 0 && pwd_result == NULL && grp_result == NULL &&
sid_str == NULL) {
ret = LDAP_NO_SUCH_OBJECT;
goto done;
}
if (domain_name == NULL) {
ret = LDAP_OPERATIONS_ERROR;
goto done;
}
ret = create_response(req, &pg_data, sid_str, id_type, domain_name, res);
if (ret != 0) {
ret = LDAP_OPERATIONS_ERROR;
goto done;
}
ret = LDAP_SUCCESS;
done:
free(buf);
free(fq_name);
free(domain_name);
free(sid_str);
return ret;
}
static void *
test(void *arg)
{
gid_t gid = *(gid_t *)arg;
gid_t ogid;
struct group grpbuf;
struct group *grp;
char **p;
char buffer[5000];
char buf[2048];
char *cpy[128];
int i;
int count1, count2;
char *s;
char *oname;
char *opasswd;
size_t len;
/* Acquire lock for running first part. */
CHECKr(pthread_mutex_lock(&display));
/* Store magic name to test for non-alteration */
grpbuf.gr_name = fail;
/* Call getgrgid_r() */
printf("gid %d\n", gid);
CHECKr(getgrgid_r(gid, &grpbuf, buffer, sizeof(buffer), &grp));
/* Test for non-alteration of group structure */
ASSERT(grp->gr_name != fail);
/* We must get the right group */
ASSERT(grp->gr_gid == gid);
s = buf; /* Keep our private buffer on the stack */
len = sizeof(buf);
/* copy gr_name */
strlcpy(oname = s, grp->gr_name, len);
len -= 1 + strlen(s);
s += 1 + strlen(s);
/* copy gr_passwd */
strlcpy(opasswd = s, grp->gr_passwd, len);
len -= 1 + strlen(s);
s += 1 + strlen(s);
/* copy gr_gid */
ogid = grp->gr_gid;
/* copy gr_mem */
for (i = 0, p = grp->gr_mem; *p; p++) {
strlcpy(cpy[i] = s, *p, len);
i++;
len -= 1 + strlen(s);
s += 1 + strlen(s);
}
cpy[i] = NULL;
#if 0
printf("now: %s:%s:%d:", grp->gr_name, grp->gr_passwd, grp->gr_gid);
for (p = grp->gr_mem; *p; p++)
printf("%s%s", *p, *(p+1) == NULL ? "": ",");
printf("\n");
#endif
#ifdef DEBUG /* debugging this program */
printf("buf = \"");
for (i = 0; i < s - buf; i++)
if (buf[i] == '\0') printf("\\0");
else printf("%c", buf[i]);
printf("\"\n");
#endif
/* Inform main that we have finished */
done_count++;
CHECKr(pthread_cond_signal(&done));
/* Allow other threads to run first part */
CHECKr(pthread_mutex_unlock(&display));
/* Acquire lock for the second part */
CHECKr(pthread_mutex_lock(&display2));
count1 = 0;
printf("before: %s:%s:%d:", oname, opasswd, ogid);
for (p = cpy; *p; p++) {
count1++;
printf("%s%s", *p, *(p+1) == NULL ? "": ",");
}
printf("\n");
count2 = 0;
printf("after: %s:%s:%d:", grp->gr_name, grp->gr_passwd, grp->gr_gid);
for (p = grp->gr_mem; *p; p++) {
count2++;
printf("%s%s", *p, *(p+1) == NULL ? "": ",");
}
printf("\n");
CHECKr(pthread_mutex_unlock(&display2));
if (count1 != count2)
return "gr_mem length changed";
for (i = 0; i < count1; i++)
if (strcmp(cpy[i], grp->gr_mem[i]) != 0)
return "gr_mem list changed";
if (strcmp(grp->gr_name, oname) != 0)
return "gr_name changed";
if (strcmp(grp->gr_passwd, opasswd) != 0)
return "gr_passwd changed";
if (grp->gr_gid != ogid)
return "gr_gid changed";
return NULL;
}
void main(int argc, char *argv[]) {
int i;
struct group *g;
struct passwd *p;
switch(argc > 1 ? argv[1][0] : -1) {
case '0': /* walk through file, spitting group entries */
while ((g=getgrent()) != NULL) {
prt_grent(g,stdout);
}
break;
case '1': /* walk arg list, finding groups */
for (i=2; i < argc; i++) {
if ((g=getgrnam(argv[i])) != NULL) {
prt_grent(g,stdout);
} else {
printf("no group '%s'\n",argv[i]);
}
}
break;
case '2': /* walk arg list, finding gid's */
for (i=2; i < argc; i++) {
gid_t x;
x = strtol(argv[i],NULL,10);
if ((g=getgrgid(x)) != NULL) {
prt_grent(g,stdout);
} else {
printf("no group '%u'\n",x);
}
}
break;
case '3': /* setgroups */
if(argc > 2) initgroups(argv[2], argc > 3 ? strtol(argv[3], 0, 10) : -1);
break;
case '4': /* walk through file, spitting group entries */
while ((p=getpwent()) != NULL) {
prt_pwent(p,stdout);
}
break;
case '5': /* walk arg list, finding groups */
for (i=2; i < argc; i++) {
if ((p=getpwnam(argv[i])) != NULL) {
prt_pwent(p,stdout);
} else {
printf("no user '%s'\n",argv[i]);
}
}
break;
case '6': /* walk arg list, finding gid's */
for (i=2; i < argc; i++) {
uid_t x;
x = strtol(argv[i],NULL,10);
if ((p=getpwuid(x)) != NULL) {
prt_pwent(p,stdout);
} else {
printf("no user '%u'\n",x);
}
}
break;
case '7': /* test getgrnam_r */
if (argc >= 3) {
struct group grp, *pgrp;
char buffer[1024 +1];
size_t bufsize = sizeof buffer;
int rc;
if (argc >= 4) {
bufsize = strtol(argv[3],NULL,10);
}
rc = getgrnam_r(argv[2], &grp, buffer, bufsize, &pgrp);
if (rc == EOK) {
if (pgrp) {
prt_grent(&grp, stdout);
} else {
printf("no group '%s'\n",argv[2]);
}
} else {
printf("error finding group '%s' %s\n",argv[2], strerror(rc));
assert(pgrp == NULL);
}
}
break;
case '8': /* test getgrgid_r */
if (argc >= 3) {
struct group grp, *pgrp;
char buffer[1024 +1];
size_t bufsize = sizeof buffer;
int rc;
gid_t x;
if (argc >= 4) {
bufsize = strtol(argv[3],NULL,10);
}
x = strtol(argv[2],NULL,10);
rc = getgrgid_r(x, &grp, buffer, bufsize, &pgrp);
if (rc == EOK) {
if (pgrp) {
prt_grent(&grp, stdout);
} else {
printf("no group '%u'\n",x);
}
} else {
printf("error finding group '%u' %s\n",x, strerror(rc));
assert(pgrp == NULL);
}
}
break;
case '9': /* walk arg list, finding groups */
if (argc >= 3) {
struct passwd pwd, *ppwd;
char buffer[1024 +1];
size_t bufsize = sizeof buffer;
int rc;
if (argc >= 4) {
bufsize = strtol(argv[3],NULL,10);
}
rc = getpwnam_r(argv[2], &pwd, buffer, bufsize, &ppwd);
if (rc == EOK) {
if (ppwd) {
prt_pwent(&pwd, stdout);
} else {
printf("no user '%s'\n",argv[2]);
}
} else {
printf("error finding user '%s' %s\n",argv[2], strerror(rc));
assert(ppwd == NULL);
}
}
break;
case 'a': /* walk arg list, finding gid's */
if (argc >= 3) {
struct passwd pwd, *ppwd;
char buffer[1024 +1];
size_t bufsize = sizeof buffer;
int rc;
uid_t x;
if (argc >= 4) {
bufsize = strtol(argv[3],NULL,10);
}
x = strtol(argv[2],NULL,10);
rc = getpwuid_r(x, &pwd, buffer, bufsize, &ppwd);
if (rc == EOK) {
if (ppwd) {
prt_pwent(&pwd, stdout);
} else {
printf("no user '%u'\n",x);
}
} else {
printf("error finding user '%u' %s\n",x, strerror(rc));
assert(ppwd == NULL);
}
}
break;
default:
fprintf(stderr,"use: %s 0 | 1 group | 2 gid | 3 user [gid] | 4 | 5 user : 6 uid | 7 group | 8 guid | 9 user | a uid \n", argv[0]);
}
}
/**
*
* gid2name: convert a gid to a name.
*
* convert a uid to a name.
*
* @param name [OUT] the name of the user
* @param gid [IN] the input gid
*
* return 1 if successful, 0 otherwise
*
*/
int gid2name(char *name, gid_t * pgid)
{
#ifndef _USE_NFSIDMAP
struct group g;
#ifndef _SOLARIS
struct group *pg = NULL;
#endif
static char buff[NFS4_MAX_DOMAIN_LEN]; /* Working area for getgrnam_r */
#endif
#ifdef _USE_NFSIDMAP
int rc;
if(gnamemap_get(*pgid, name) == ID_MAPPER_SUCCESS)
{
LogFullDebug(COMPONENT_IDMAPPER,
"gid2name: unamemap_get gid %d returned %s",
*pgid, name);
return 1;
}
else
{
if(!nfsidmap_set_conf())
{
LogCrit(COMPONENT_IDMAPPER,
"gid2name: nfsidmap_set_conf failed");
return 0;
}
rc = nfs4_gid_to_name(*pgid, idmap_domain, name, NFS4_MAX_DOMAIN_LEN);
if(rc != 0)
{
LogDebug(COMPONENT_IDMAPPER,
"gid2name: nfs4_gid_to_name %d returned %d (%s)",
*pgid, -rc, strerror(-rc));
return 0;
}
LogFullDebug(COMPONENT_IDMAPPER,
"gid2name: nfs4_gid_to_name gid %d returned %s",
*pgid, name);
if(gidmap_add(name, *pgid) != ID_MAPPER_SUCCESS)
{
LogCrit(COMPONENT_IDMAPPER,
"gid2name: gidmap_add %s %d failed",
name, *pgid);
return 0;
}
}
return 1;
#else
if(gnamemap_get(*pgid, name) == ID_MAPPER_SUCCESS)
{
LogFullDebug(COMPONENT_IDMAPPER,
"gid2name: gnamemap_get gid %d returned %s",
*pgid, name);
return 1;
}
else
{
#ifdef _SOLARIS
if(getgrgid_r(*pgid, &g, buff, NFS4_MAX_DOMAIN_LEN) != 0)
#else
if((getgrgid_r(*pgid, &g, buff, NFS4_MAX_DOMAIN_LEN, &pg) != 0) ||
(pg == NULL))
#endif /* _SOLARIS */
{
LogFullDebug(COMPONENT_IDMAPPER,
"gid2name: getgrgid_r %d failed",
*pgid);
return 0;
}
strncpy(name, g.gr_name, NFS4_MAX_DOMAIN_LEN);
LogFullDebug(COMPONENT_IDMAPPER,
"gid2name: getgrgid_r gid %d returned %s",
*pgid, name);
if(gidmap_add(name, *pgid) != ID_MAPPER_SUCCESS)
{
LogCrit(COMPONENT_IDMAPPER,
"gid2name: gidmap_add %s %d failed",
name, *pgid);
return 0;
}
}
return 1;
#endif /* _USE_NFSIDMAP */
} /* gid2name */
struct group *getgrnam_ext(
char **user_buf,
char *grp_name) /* I */
{
struct group *grp;
char *buf;
long bufsize;
struct group *result;
int rc;
*user_buf = NULL;
if (grp_name == NULL)
return(NULL);
bufsize = sysconf(_SC_GETGR_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);
}
int alloc_size = sizeof(struct group);
grp = (struct group *)calloc(1, alloc_size);
if (grp == NULL)
{
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, __func__, "could not allocate passwd structure");
free(buf);
return(NULL);
}
rc = getgrnam_r(grp_name, grp, buf, bufsize, &result);
if ((rc) ||
(result == NULL))
{
/* See if a number was passed in instead of a name */
if (isdigit(grp_name[0]))
{
rc = getgrgid_r(atoi(grp_name), grp, buf, bufsize, &result);
if ((rc == 0) &&
(result != NULL))
{
*user_buf = buf;
return(grp);
}
}
sprintf(buf, "getgrnam_r failed: %d", rc);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, __func__, buf);
free(buf);
free(grp);
return (NULL);
}
*user_buf = buf;
return(grp);
} /* END getgrnam_ext() */
static dbus_bool_t
fill_group_info (DBusGroupInfo *info,
dbus_gid_t gid,
const DBusString *groupname,
DBusError *error)
{
const char *group_c_str;
_dbus_assert (groupname != NULL || gid != DBUS_GID_UNSET);
_dbus_assert (groupname == NULL || gid == DBUS_GID_UNSET);
if (groupname)
group_c_str = _dbus_string_get_const_data (groupname);
else
group_c_str = NULL;
/* For now assuming that the getgrnam() and getgrgid() flavors
* always correspond to the pwnam flavors, if not we have
* to add more configure checks.
*/
#if defined (HAVE_POSIX_GETPWNAM_R) || defined (HAVE_NONPOSIX_GETPWNAM_R)
{
struct group *g;
int result;
size_t buflen;
char *buf;
struct group g_str;
dbus_bool_t b;
/* retrieve maximum needed size for buf */
buflen = sysconf (_SC_GETGR_R_SIZE_MAX);
/* sysconf actually returns a long, but everything else expects size_t,
* so just recast here.
* https://bugs.freedesktop.org/show_bug.cgi?id=17061
*/
if ((long) buflen <= 0)
buflen = 1024;
result = -1;
while (1)
{
buf = dbus_malloc (buflen);
if (buf == NULL)
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return FALSE;
}
g = NULL;
#ifdef HAVE_POSIX_GETPWNAM_R
if (group_c_str)
result = getgrnam_r (group_c_str, &g_str, buf, buflen,
&g);
else
result = getgrgid_r (gid, &g_str, buf, buflen,
&g);
#else
g = getgrnam_r (group_c_str, &g_str, buf, buflen);
result = 0;
#endif /* !HAVE_POSIX_GETPWNAM_R */
/* Try a bigger buffer if ERANGE was returned:
https://bugs.freedesktop.org/show_bug.cgi?id=16727
*/
if (result == ERANGE && buflen < 512 * 1024)
{
dbus_free (buf);
buflen *= 2;
}
else
{
break;
}
}
if (result == 0 && g == &g_str)
{
b = fill_user_info_from_group (g, info, error);
dbus_free (buf);
return b;
}
else
{
dbus_set_error (error, _dbus_error_from_errno (errno),
"Group %s unknown or failed to look it up\n",
group_c_str ? group_c_str : "???");
dbus_free (buf);
return FALSE;
}
}
#else /* ! HAVE_GETPWNAM_R */
{
/* I guess we're screwed on thread safety here */
struct group *g;
g = getgrnam (group_c_str);
if (g != NULL)
{
return fill_user_info_from_group (g, info, error);
}
else
{
dbus_set_error (error, _dbus_error_from_errno (errno),
"Group %s unknown or failed to look it up\n",
group_c_str ? group_c_str : "???");
return FALSE;
}
}
#endif /* ! HAVE_GETPWNAM_R */
}
/*
* public static native Stat fstat(FileDescriptor fd);
*/
JNIEXPORT jobject JNICALL
Java_org_apache_hadoop_io_nativeio_NativeIO_fstat(
JNIEnv *env, jclass clazz, jobject fd_object)
{
jobject ret = NULL;
char *pw_buf = NULL;
int fd = fd_get(env, fd_object);
PASS_EXCEPTIONS_GOTO(env, cleanup);
struct stat s;
int rc = fstat(fd, &s);
if (rc != 0) {
throw_ioe(env, errno);
goto cleanup;
}
size_t pw_buflen = get_pw_buflen();
if ((pw_buf = malloc(pw_buflen)) == NULL) {
THROW(env, "java/lang/OutOfMemoryError", "Couldn't allocate memory for pw buffer");
goto cleanup;
}
// Grab username
struct passwd pwd, *pwdp;
while ((rc = getpwuid_r(s.st_uid, &pwd, pw_buf, pw_buflen, &pwdp)) != 0) {
if (rc != ERANGE) {
throw_ioe(env, rc);
goto cleanup;
}
free(pw_buf);
pw_buflen *= 2;
if ((pw_buf = malloc(pw_buflen)) == NULL) {
THROW(env, "java/lang/OutOfMemoryError", "Couldn't allocate memory for pw buffer");
goto cleanup;
}
}
assert(pwdp == &pwd);
jstring jstr_username = (*env)->NewStringUTF(env, pwd.pw_name);
if (jstr_username == NULL) goto cleanup;
// Grab group
struct group grp, *grpp;
while ((rc = getgrgid_r(s.st_gid, &grp, pw_buf, pw_buflen, &grpp)) != 0) {
if (rc != ERANGE) {
throw_ioe(env, rc);
goto cleanup;
}
free(pw_buf);
pw_buflen *= 2;
if ((pw_buf = malloc(pw_buflen)) == NULL) {
THROW(env, "java/lang/OutOfMemoryError", "Couldn't allocate memory for pw buffer");
goto cleanup;
}
}
assert(grpp == &grp);
jstring jstr_groupname = (*env)->NewStringUTF(env, grp.gr_name);
PASS_EXCEPTIONS_GOTO(env, cleanup);
// Construct result
ret = (*env)->NewObject(env, stat_clazz, stat_ctor,
jstr_username, jstr_groupname, s.st_mode);
cleanup:
if (pw_buf != NULL) free(pw_buf);
return ret;
}
