ssize_t deleteAttr( const char* path, const char* attrname ) {
char* name = addNamespacePrefix( attrname );
ssize_t ret = removexattr( path, name );
free( name );
name = NULL;
checkReturnValue( "deleteAttr", ret );
return ret;
}
/*
delete one extended attributes from the file
*/
void delete_xattr(const char* attr_name, const char* filename, int nofollow) {
int rc = removexattr(
filename,
attr_name,
(nofollow ? XATTR_NOFOLLOW : 0)
);
if(rc < 0) {
perror("removexattr");
exit(1);
}
}
virtual int run( int checkpoint ) override {
test_path = mnt_dir_ ;
A_path = mnt_dir_ + "/A";
AC_path = mnt_dir_ + "/A/C";
B_path = mnt_dir_ + "/B";
foo_path = mnt_dir_ + "/foo";
bar_path = mnt_dir_ + "/bar";
Afoo_path = mnt_dir_ + "/A/foo";
Abar_path = mnt_dir_ + "/A/bar";
Bfoo_path = mnt_dir_ + "/B/foo";
Bbar_path = mnt_dir_ + "/B/bar";
ACfoo_path = mnt_dir_ + "/A/C/foo";
ACbar_path = mnt_dir_ + "/A/C/bar";
int local_checkpoint = 0 ;
int fd_foo = cm_->CmOpen(foo_path.c_str() , O_RDWR|O_CREAT , 0777);
if ( fd_foo < 0 ) {
cm_->CmClose( fd_foo);
return errno;
}
if ( fsetxattr( fd_foo, "user.xattr1", "val1 ", 4, 0 ) < 0){
return errno;
}
if ( removexattr(foo_path.c_str() , "user.xattr1") < 0){
return errno;
}
if ( cm_->CmFsync( fd_foo) < 0){
return errno;
}
if ( cm_->CmCheckpoint() < 0){
return -1;
}
local_checkpoint += 1;
if (local_checkpoint == checkpoint) {
return 1;
}
if ( cm_->CmClose ( fd_foo) < 0){
return errno;
}
return 0;
}
int rep_removexattr (const char *path, const char *name)
{
#if defined(HAVE_REMOVEXATTR)
#ifndef XATTR_ADDITIONAL_OPTIONS
return removexattr(path, name);
#else
/* So that we do not recursivly call this function */
#undef removexattr
int options = 0;
return removexattr(path, name, options);
#endif
#elif defined(HAVE_REMOVEEA)
return removeea(path, name);
#elif defined(HAVE_EXTATTR_DELETE_FILE)
char *s;
int attrnamespace = (strncmp(name, "system", 6) == 0) ?
EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
const char *attrname = ((s=strchr(name, '.')) == NULL) ? name : s + 1;
return extattr_delete_file(path, attrnamespace, attrname);
#elif defined(HAVE_ATTR_REMOVE)
int flags = 0;
char *attrname = strchr(name,'.') + 1;
if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
return attr_remove(path, attrname, flags);
#elif defined(HAVE_ATTROPEN)
int ret = -1;
int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
if (attrdirfd >= 0) {
ret = solaris_unlinkat(attrdirfd, name);
close(attrdirfd);
}
return ret;
#else
errno = ENOSYS;
return -1;
#endif
}
// Test removexattr
void barrier_removexattr_test( char* file ) {
int ret = -1;
// Set a xattr on the filepath
barrier_setxattr_test( file );
ret = removexattr( file, "user.filename" );
if( ret == 0 ) {
fprintf( stderr, "Removed xattr on file - %s\n", file );
} else {
fprintf( stderr, "Error while removexattr operation - %s\n", strerror(errno) );
}
}
asmlinkage long
sys_lremovexattr(char __user *path, char __user *name)
{
struct nameidata nd;
int error;
error = user_path_walk_link(path, &nd);
if (error)
return error;
error = removexattr(nd.dentry, name);
path_release(&nd);
return error;
}
asmlinkage long
sys_fremovexattr(int fd, char __user *name)
{
struct file *f;
int error = -EBADF;
f = fget(fd);
if (!f)
return error;
error = removexattr(f->f_dentry, name);
fput(f);
return error;
}
static int
spade_removexattr(const char *path, const char *name) {
int res;
if (strcmp(name, A_KAUTH_FILESEC_XATTR) == 0) {
char new_name[MAXPATHLEN];
memcpy(new_name, A_KAUTH_FILESEC_XATTR, sizeof (A_KAUTH_FILESEC_XATTR));
memcpy(new_name, G_PREFIX, sizeof (G_PREFIX) - 1);
res = removexattr(path, new_name, XATTR_NOFOLLOW);
} else {
res = removexattr(path, name, XATTR_NOFOLLOW);
}
if (res == -1) {
return -errno;
}
return 0;
}
int main(int argc, char *argv[]) {
FILE *file;
char *prog;
char line[256];
int pid, status;
int i;
if (argc < 2) {
printf("ERROR: no script specified.\n");
return -1;
}
file = fopen(argv[1], "r");
if (file == NULL) {
printf("ERROR: cannot open %s.", argv[0]);
return -1;
}
if (argc > 2)
prog = argv[2];
else
prog = "/bin/bash";
while (1) {
fgets(line, sizeof(line), file);
if (feof(file))
break;
pid = process_line(line, prog);
if (pid > 0) {
waitpid(pid, &status, 0);
break;
}
}
fclose(file);
if (pid == 0) {
system(prog);
return 0;
}
if (pid < 0)
system(prog);
for (i = 0; i < reset_files_cnt; i++) {
if (reset_attr_lens[i] > 0) {
setxattr(reset_files[i], "security.dcac.pm", reset_attrs[i], reset_attr_lens[i], 0);
} else {
removexattr(reset_files[i], "security.dcac.pm");
}
}
}
int cow_removexattr(const char *path, const char *attrname)
{
int i=0;
int res = 0;
LOG("%s",path);
struct cow_config *conf = cow_getConfig();
char *fqpath = NULL;
FORDSTDIRS_BEGIN(i, res, path, conf, fqpath);
res = removexattr(fqpath, attrname);
FORDSTDIRS_END(fqpath);
return 0;
}
static bool update_capabilities(const char* path, uint64_t capabilities) {
if (capabilities == 0) {
// Ensure we clean up in case the capabilities weren't 0 in the past.
removexattr(path, XATTR_NAME_CAPS);
return true;
}
vfs_cap_data cap_data = {};
cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE;
cap_data.data[0].permitted = (capabilities & 0xffffffff);
cap_data.data[0].inheritable = 0;
cap_data.data[1].permitted = (capabilities >> 32);
cap_data.data[1].inheritable = 0;
return setxattr(path, XATTR_NAME_CAPS, &cap_data, sizeof(cap_data), 0) != -1;
}
static int mhdd_removexattr(const char *path, const char *attrname)
{
char * real_path = find_path(path);
if (!real_path)
return -ENOENT;
mhdd_debug(MHDD_MSG,
"mhdd_removexattr: path = %s name = %s\n",
real_path, attrname);
int res = removexattr(real_path, attrname);
free(real_path);
if (res == -1) return -errno;
return 0;
}
asmlinkage long
sys_fremovexattr(int fd, char __user *name)
{
struct file *f;
struct dentry *dentry;
int error = -EBADF;
f = fget(fd);
if (!f)
return error;
dentry = f->f_path.dentry;
audit_inode(NULL, dentry);
error = removexattr(dentry, name);
fput(f);
return error;
}
static int
_removexattr (const char *xattr, const char *path,
int (*removexattr) (const char *path, const char *name))
{
int r;
CHROOT_IN;
r = removexattr (path, xattr);
CHROOT_OUT;
if (r == -1) {
reply_with_perror ("removexattr");
return -1;
}
return 0;
}
int sys_removexattr (const char *path, const char *name)
{
#if defined(HAVE_REMOVEXATTR)
return removexattr(path, name);
#elif defined(HAVE_ATTR_REMOVE)
int flags = 0;
char *attrname = strchr(name,'.') +1;
if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
return attr_remove(path, attrname, flags);
#else
errno = ENOSYS;
return -1;
#endif
}
SYSCALL_DEFINE2(lremovexattr, const char __user *, pathname,
const char __user *, name)
{
struct path path;
int error;
error = user_lpath(pathname, &path);
if (error)
return error;
error = mnt_want_write(path.mnt);
if (!error) {
error = removexattr(path.dentry, name);
mnt_drop_write(path.mnt);
}
path_put(&path);
return error;
}
int fs_real_removexattr(const char *path, const char *name)
{
char ppath[FS_MAXPATH];
struct stat v_stbuf;
char *newpath=ppath;
FSDEBUG("path=%s",path);
isofs_inode *inode = fs_lookup(path);
if (inode)
{
FSDEBUG("you don't have permission on %s",path);
return -ENOTSUP;
}
if (fs_home_stat(path,&newpath,&v_stbuf) == -1) fs_file_dup(path,newpath);
if (removexattr(newpath,name) == 0) return 0;
return -errno;
}
static int convert_ecidx_xattr2path(uint64_t oid, const char *wd,
uint32_t epoch, uint8_t ec_index,
struct vnode_info *info,
void *arg)
{
int ret = 0;
uint8_t idx;
char path[PATH_MAX + 1], new_path[PATH_MAX + 1];
bool is_stale = *(bool *)arg;
if (is_stale)
snprintf(path, PATH_MAX, "%s/%016"PRIx64".%u", wd, oid, epoch);
else
snprintf(path, PATH_MAX, "%s/%016"PRIx64, wd, oid);
if (getxattr(path, OLD_ECNAME, &idx, sizeof(uint8_t)) < 0) {
sd_info("object: %s doesn't have its ec index in xattr: %m",
path);
goto out;
}
if (is_stale)
snprintf(new_path, PATH_MAX, "%s/%016"PRIx64"_%u.%u",
wd, oid, idx, epoch);
else
snprintf(new_path, PATH_MAX, "%s/%016"PRIx64"_%u",
wd, oid, idx);
if (rename(path, new_path) < 0) {
sd_emerg("rename from %s to %s failed: %m", path, new_path);
ret = -1;
goto out;
}
if (removexattr(new_path, OLD_ECNAME) < 0) {
sd_emerg("remove xattr %s from path %s failed: %m",
OLD_ECNAME, new_path);
ret = -1;
}
out:
return ret;
}
static int unionfs_removexattr(const char *path, const char *name) {
DBG("%s\n", path);
int i = find_rw_branch_cow(path);
if (i == -1) RETURN(-errno);
char p[PATHLEN_MAX];
if (BUILD_PATH(p, uopt.branches[i].path, path)) RETURN(-ENAMETOOLONG);
#if __APPLE__
int res = removexattr(p, name, XATTR_NOFOLLOW);
#else
int res = lremovexattr(p, name);
#endif
if (res == -1) RETURN(-errno);
RETURN(res);
}
SYSCALL_DEFINE2(fremovexattr, int, fd, const char __user *, name)
{
struct file *f;
struct dentry *dentry;
int error = -EBADF;
f = fget(fd);
if (!f)
return error;
dentry = f->f_path.dentry;
audit_inode(NULL, dentry);
error = mnt_want_write(f->f_path.mnt);
if (!error) {
error = removexattr(dentry, name);
mnt_drop_write(f->f_path.mnt);
}
fput(f);
return error;
}
int remove_ea(enum FILE_TYPE ft, int fd)
{
int ret = 0;
switch (ft) {
case NORMAL:
ret = fremovexattr(fd, xattr_name);
if (ret < 0) {
ret = errno;
fprintf(stderr, "Failed at fremovexattr(errno:%d,%s) "
"on %s:xattr_name=%s\n", ret, strerror(ret),
filename, xattr_name);
ret = -1;
}
break;
case SYMLINK:
ret = lremovexattr(filename, xattr_name);
if (ret < 0) {
ret = errno;
fprintf(stderr, "Failed at lremovexattr(errno:%d,%s) "
"on %s:xattr_name=%s\n", ret, strerror(ret),
filename, xattr_name);
ret = -1;
}
break;
case DIRECTORY:
ret = removexattr(filename, xattr_name);
if (ret < 0) {
ret = errno;
fprintf(stderr, "Failed at removexattr(errno:%d,%s) "
"on %s:xattr_name=%s\n", ret, strerror(ret),
filename, xattr_name);
ret = -1;
}
break;
default:
break;
}
return ret;
}
int main(int argc,char *argv[])
{
char name[255];
char value[100];
int isRemove = 0;
while((opt = getopt(argc,argv,"u:v:x:")) != -1)
{
switch(opt)
{
case 'u':
strncpy(name,optarg,strlen(optarg));
break;
case 'v':
strncpy(value,optarg,strlen(optarg));
break;
case 'x':
isRemove = 1;
strncpy(name,optarg,strlen(optarg));
break;
case '?':
//usageError(argv[0]);
break;
}
}
if (!isRemove)
{
setxattr(argv[optind],name,value,sizeof(value),0);
}
else
{
printf("remove EA name=%s\n",name);
removexattr(argv[optind],name);
}
exit(EXIT_SUCCESS);
}
virtual int run(int checkpoint) override {
int local_checkpoint = 0;
const int fd_foo = open(foo_path.c_str(), O_RDWR | O_CREAT, TEST_FILE_PERMS);
if (fd_foo < 0) {
return -1;
}
//remove user.xattr2
int res = removexattr(foo_path.c_str(), "user.xattr2");
if (res < 0) {
return -1;
}
//system("setfattr -x user.xattr2 /mnt/snapshot/foo");
//fsync file_foo
res = fsync(fd_foo);
if (res < 0){
return -6;
}
//Make a user checkpoint here. Checkpoint must be 1 beyond this point.
if (Checkpoint() < 0){
return -5;
}
local_checkpoint += 1;
if (local_checkpoint == checkpoint) {
return 1;
}
//Close open files
close(fd_foo);
return 0;
}
int
dir_based_fops (char *dirname)
{
int ret = -1;
DIR *dp = NULL;
char buff[255] = {0,};
struct dirent *dbuff = {0,};
struct stat stbuff = {0,};
char newdname[255] = {0,};
char *cwd = NULL;
ret = mkdir (dirname, 0755);
if (ret < 0) {
fprintf (stderr, "mkdir failed: %s\n", strerror (errno));
goto out;
}
dp = opendir (dirname);
if (dp == NULL) {
fprintf (stderr, "opendir failed: %s\n", strerror (errno));
goto out;
}
dbuff = readdir (dp);
if (NULL == dbuff) {
fprintf (stderr, "readdir failed: %s\n", strerror (errno));
goto out;
}
ret = closedir (dp);
if (ret < 0) {
fprintf (stderr, "closedir failed: %s\n", strerror (errno));
goto out;
}
ret = stat (dirname, &stbuff);
if (ret < 0) {
fprintf (stderr, "stat failed: %s\n", strerror (errno));
goto out;
}
ret = chmod (dirname, 0744);
if (ret < 0) {
fprintf (stderr, "chmod failed: %s\n", strerror (errno));
goto out;
}
ret = chown (dirname, 10001, 10001);
if (ret < 0) {
fprintf (stderr, "chmod failed: %s\n", strerror (errno));
goto out;
}
ret = setxattr (dirname, "trusted.xattr-test", "working", 8, 0);
if (ret < 0) {
fprintf (stderr, "setxattr failed: %s\n", strerror (errno));
goto out;
}
ret = listxattr (dirname, NULL, 0);
if (ret <= 0) {
ret = -1;
fprintf (stderr, "listxattr failed: %s\n", strerror (errno));
goto out;
}
ret = getxattr (dirname, "trusted.xattr-test", NULL, 0);
if (ret <= 0) {
ret = -1;
fprintf (stderr, "getxattr failed: %s\n", strerror (errno));
goto out;
}
ret = removexattr (dirname, "trusted.xattr-test");
if (ret < 0) {
fprintf (stderr, "removexattr failed: %s\n", strerror (errno));
goto out;
}
strcpy (newdname, dirname);
strcat (newdname, "/../");
ret = chdir (newdname);
if (ret < 0) {
fprintf (stderr, "chdir failed: %s\n", strerror (errno));
goto out;
}
cwd = getcwd (buff, 255);
if (NULL == cwd) {
fprintf (stderr, "getcwd failed: %s\n", strerror (errno));
goto out;
}
strcpy (newdname, dirname);
strcat (newdname, "new");
ret = rename (dirname, newdname);
if (ret < 0) {
fprintf (stderr, "rename failed: %s\n", strerror (errno));
goto out;
}
ret = rmdir (newdname);
if (ret < 0) {
fprintf (stderr, "rmdir failed: %s\n", strerror (errno));
return ret;
}
out:
rmdir (dirname);
return ret;
}
int
path_based_fops (char *filename)
{
int ret = -1;
int fd = 0;
struct stat stbuf = {0,};
char newfilename[255] = {0,};
fd = creat (filename, 0644);
if (fd < 0) {
fprintf (stderr, "creat failed: %s\n", strerror (errno));
goto out;
}
ret = truncate (filename, 0);
if (ret < 0) {
fprintf (stderr, "truncate failed: %s\n", strerror (errno));
goto out;
}
ret = stat (filename, &stbuf);
if (ret < 0) {
fprintf (stderr, "stat failed: %s\n", strerror (errno));
goto out;
}
ret = chmod (filename, 0640);
if (ret < 0) {
fprintf (stderr, "chmod failed: %s\n", strerror (errno));
goto out;
}
ret = chown (filename, 10001, 10001);
if (ret < 0) {
fprintf (stderr, "chown failed: %s\n", strerror (errno));
goto out;
}
ret = setxattr (filename, "trusted.xattr-test", "working", 8, 0);
if (ret < 0) {
fprintf (stderr, "setxattr failed: %s\n", strerror (errno));
goto out;
}
ret = listxattr (filename, NULL, 0);
if (ret <= 0) {
ret = -1;
fprintf (stderr, "listxattr failed: %s\n", strerror (errno));
goto out;
}
ret = getxattr (filename, "trusted.xattr-test", NULL, 0);
if (ret <= 0) {
ret = -1;
fprintf (stderr, "getxattr failed: %s\n", strerror (errno));
goto out;
}
ret = removexattr (filename, "trusted.xattr-test");
if (ret < 0) {
fprintf (stderr, "removexattr failed: %s\n", strerror (errno));
goto out;
}
ret = access (filename, R_OK|W_OK);
if (ret < 0) {
fprintf (stderr, "access failed: %s\n", strerror (errno));
goto out;
}
strcpy (newfilename, filename);
strcat(newfilename, "_new");
ret = rename (filename, newfilename);
if (ret < 0) {
fprintf (stderr, "rename failed: %s\n", strerror (errno));
goto out;
}
unlink (newfilename);
out:
if (fd)
close (fd);
unlink (filename);
return ret;
}
int
path_based_fops(char *filename)
{
int ret = -1;
int fd = 0;
int result = 0;
struct stat stbuf = {
0,
};
char newfilename[255] = {
0,
};
char *hardlink = "linkfile-hard.txt";
char *symlnk = "linkfile-soft.txt";
char buf[1024] = {
0,
};
fd = creat(filename, 0644);
if (fd < 0) {
fprintf(stderr, "creat failed: %s\n", strerror(errno));
return ret;
}
ret = truncate(filename, 0);
if (ret < 0) {
fprintf(stderr, "truncate failed: %s\n", strerror(errno));
result |= ret;
}
ret = stat(filename, &stbuf);
if (ret < 0) {
fprintf(stderr, "stat failed: %s\n", strerror(errno));
result |= ret;
}
ret = chmod(filename, 0640);
if (ret < 0) {
fprintf(stderr, "chmod failed: %s\n", strerror(errno));
result |= ret;
}
ret = chown(filename, 10001, 10001);
if (ret < 0) {
fprintf(stderr, "chown failed: %s\n", strerror(errno));
result |= ret;
}
ret = setxattr(filename, "trusted.xattr-test", "working", 8, 0);
if (ret < 0) {
fprintf(stderr, "setxattr failed: %s\n", strerror(errno));
result |= ret;
}
ret = listxattr(filename, NULL, 0);
if (ret <= 0) {
ret = -1;
fprintf(stderr, "listxattr failed: %s\n", strerror(errno));
result |= ret;
}
ret = getxattr(filename, "trusted.xattr-test", NULL, 0);
if (ret <= 0) {
fprintf(stderr, "getxattr failed: %s\n", strerror(errno));
result |= ret;
}
ret = removexattr(filename, "trusted.xattr-test");
if (ret < 0) {
fprintf(stderr, "removexattr failed: %s\n", strerror(errno));
result |= ret;
}
ret = access(filename, R_OK | W_OK);
if (ret < 0) {
fprintf(stderr, "access failed: %s\n", strerror(errno));
result |= ret;
}
ret = link(filename, hardlink);
if (ret < 0) {
fprintf(stderr, "link failed: %s\n", strerror(errno));
result |= ret;
}
unlink(hardlink);
ret = symlink(filename, symlnk);
if (ret < 0) {
fprintf(stderr, "symlink failed: %s\n", strerror(errno));
result |= ret;
}
ret = readlink(symlnk, buf, sizeof(buf));
if (ret < 0) {
fprintf(stderr, "readlink failed: %s\n", strerror(errno));
result |= ret;
}
unlink(symlnk);
/* Create a character special file */
ret = mknod("cspecial", S_IFCHR | S_IRWXU | S_IRWXG, makedev(2, 3));
if (ret < 0) {
fprintf(stderr, "cpsecial mknod failed: %s\n", strerror(errno));
result |= ret;
}
unlink("cspecial");
ret = mknod("bspecial", S_IFBLK | S_IRWXU | S_IRWXG, makedev(4, 5));
if (ret < 0) {
fprintf(stderr, "bspecial mknod failed: %s\n", strerror(errno));
result |= ret;
}
unlink("bspecial");
#ifdef linux
ret = mknod("fifo", S_IFIFO | S_IRWXU | S_IRWXG, 0);
#else
ret = mkfifo("fifo", 0);
#endif
if (ret < 0) {
fprintf(stderr, "fifo mknod failed: %s\n", strerror(errno));
result |= ret;
}
unlink("fifo");
#ifdef linux
ret = mknod("sock", S_IFSOCK | S_IRWXU | S_IRWXG, 0);
if (ret < 0) {
fprintf(stderr, "sock mknod failed: %s\n", strerror(errno));
result |= ret;
}
#else
{
int s;
const char *pathname = "sock";
struct sockaddr_un addr;
s = socket(PF_LOCAL, SOCK_STREAM, 0);
memset(&addr, 0, sizeof(addr));
strncpy(addr.sun_path, pathname, sizeof(addr.sun_path));
ret = bind(s, (const struct sockaddr *)&addr, SUN_LEN(&addr));
if (ret < 0) {
fprintf(stderr, "fifo mknod failed: %s\n", strerror(errno));
result |= ret;
}
close(s);
}
#endif
unlink("sock");
strcpy(newfilename, filename);
strcat(newfilename, "_new");
ret = rename(filename, newfilename);
if (ret < 0) {
fprintf(stderr, "rename failed: %s\n", strerror(errno));
result |= ret;
}
unlink(newfilename);
if (fd)
close(fd);
unlink(filename);
return result;
}
int fsfr_unset_attr(const char *fpath, const char* name)
{
return removexattr(fpath,name)?-errno:0;
}
int sys_lremovexattr(const char *path, const char *name)
{
return removexattr(path, name, XATTR_NOFOLLOW);
}
static int pifs_removexattr(const char *path, const char *name)
{
FULL_PATH(path);
int ret = removexattr(full_path, name);
return ret == -1 ? -errno : ret;
}
int main(int argc, char **argv)
{
ssize_t len, names_len = 0;
int i, rc;
char buffer[1024];
char *ptr = buffer;
if (argc != 2) {
fprintf(stderr, "Usage: %s file\n", argv[0]);
exit(EXIT_FAILURE);
}
for (i = 0; names[i]; i++) {
if (setxattr(argv[1], names[i], values[i], strlen(values[i]), 0) < 0)
exit(EXIT_FAILURE);
names_len += 1 + strlen(names[i]);
}
/*
* Sanity check that listxattr returns correct length
*/
len = listxattr(argv[1], NULL, 0);
if (len != names_len)
exit(EXIT_FAILURE);
len = listxattr(argv[1], buffer, sizeof(buffer));
if (len < 0)
exit(EXIT_FAILURE);
/*
* Check listxattr names match what has been just set
*/
for (i = 0; names[i]; i++) {
if (strcmp(names[i], ptr))
exit(EXIT_FAILURE);
ptr += strlen(ptr) + 1;
}
/*
* Check contents of xattr
*/
for (i = 0; names[i]; i++) {
len = getxattr(argv[1], names[i], buffer, sizeof(buffer));
if (len < 0)
exit(EXIT_FAILURE);
buffer[len] = '\0';
if (strcmp(values[i], buffer))
exit(EXIT_FAILURE);
}
/*
* Remove xattr
*/
for (i = 0; names[i]; i++) {
rc = removexattr(argv[1], names[i]);
if (rc < 0)
exit(EXIT_FAILURE);
}
/*
* ..and there should be no xattrs left
*/
len = listxattr(argv[1], NULL, 0);
if (len != 0)
exit(EXIT_FAILURE);
exit(EXIT_SUCCESS);
}
