Before this commit, most library calls looked something like...
int result = foo(x,y);
if (result == whatever) {
...
}
and then the "result" variable was never used again. There's no need
to introduce the new name, and it probably only increases
confusion. So, this commit eliminates them all.
return false;
}
struct stat s;
return false;
}
struct stat s;
- int result = fstat(fd, &s);
- if (result == 0) {
+ if (fstat(fd, &s) == 0) {
return (s.st_nlink == 1 || S_ISDIR(s.st_mode));
}
else {
return (s.st_nlink == 1 || S_ISDIR(s.st_mode));
}
else {
- int result = fstat(fd, &s);
- if (result == 0) {
+ if (fstat(fd, &s) == 0) {
return S_ISREG(s.st_mode);
}
else {
return S_ISREG(s.st_mode);
}
else {
/* If the path is relative, interpret it relative to the current
working directory (just like the access() system call). */
/* If the path is relative, interpret it relative to the current
working directory (just like the access() system call). */
- int result = faccessat(AT_FDCWD, path, F_OK, flags);
-
- if (result == 0) {
+ if (faccessat(AT_FDCWD, path, F_OK, flags) == 0) {
- int result = lstat(path, &s);
- if (result == 0) {
+ if (lstat(path, &s) == 0) {
return S_ISDIR(s.st_mode);
}
else {
return S_ISDIR(s.st_mode);
}
else {
- int result = fstat(fd, &s);
- if (result == 0) {
+ if (fstat(fd, &s) == 0) {
return S_ISDIR(s.st_mode);
}
else {
return S_ISDIR(s.st_mode);
}
else {
acl_entry_t entry) {
acl_tag_t entry_tag;
acl_entry_t entry) {
acl_tag_t entry_tag;
- int gt_result = acl_get_tag_type(entry, &entry_tag);
- if (gt_result == ACL_ERROR) {
+ if (acl_get_tag_type(entry, &entry_tag) == ACL_ERROR) {
perror("acl_set_entry (acl_get_tag_type)");
return ACL_ERROR;
}
acl_permset_t entry_permset;
perror("acl_set_entry (acl_get_tag_type)");
return ACL_ERROR;
}
acl_permset_t entry_permset;
- int ps_result = acl_get_permset(entry, &entry_permset);
- if (ps_result == ACL_ERROR) {
+ if (acl_get_permset(entry, &entry_permset) == ACL_ERROR) {
perror("acl_set_entry (acl_get_permset)");
return ACL_ERROR;
}
perror("acl_set_entry (acl_get_permset)");
return ACL_ERROR;
}
while (result == ACL_SUCCESS) {
acl_tag_t existing_tag = ACL_UNDEFINED_TAG;
while (result == ACL_SUCCESS) {
acl_tag_t existing_tag = ACL_UNDEFINED_TAG;
- int tag_result = acl_get_tag_type(existing_entry, &existing_tag);
- if (tag_result == ACL_ERROR) {
+ if (acl_get_tag_type(existing_entry, &existing_tag) == ACL_ERROR) {
perror("set_acl_tag_permset (acl_get_tag_type)");
return ACL_ERROR;
}
perror("set_acl_tag_permset (acl_get_tag_type)");
return ACL_ERROR;
}
match one of them, we're allowed to return ACL_SUCCESS
below and bypass the rest of the function. */
acl_permset_t existing_permset;
match one of them, we're allowed to return ACL_SUCCESS
below and bypass the rest of the function. */
acl_permset_t existing_permset;
- int gep_result = acl_get_permset(existing_entry, &existing_permset);
- if (gep_result == ACL_ERROR) {
+ if (acl_get_permset(existing_entry, &existing_permset) == ACL_ERROR) {
perror("acl_set_entry (acl_get_permset)");
return ACL_ERROR;
}
perror("acl_set_entry (acl_get_permset)");
return ACL_ERROR;
}
- int s_result = acl_set_permset(existing_entry, entry_permset);
- if (s_result == ACL_ERROR) {
+ if (acl_set_permset(existing_entry, entry_permset) == ACL_ERROR) {
perror("acl_set_entry (acl_set_permset)");
return ACL_ERROR;
}
perror("acl_set_entry (acl_set_permset)");
return ACL_ERROR;
}
* be fed to acl_free(). In other words, we should still be freeing
* the right thing, even if the value pointed to by aclp changes.
*/
* be fed to acl_free(). In other words, we should still be freeing
* the right thing, even if the value pointed to by aclp changes.
*/
- int c_result = acl_create_entry(aclp, &new_entry);
- if (c_result == ACL_ERROR) {
+ if (acl_create_entry(aclp, &new_entry) == ACL_ERROR) {
perror("acl_set_entry (acl_create_entry)");
return ACL_ERROR;
}
perror("acl_set_entry (acl_create_entry)");
return ACL_ERROR;
}
- int st_result = acl_set_tag_type(new_entry, entry_tag);
- if (st_result == ACL_ERROR) {
+ if (acl_set_tag_type(new_entry, entry_tag) == ACL_ERROR) {
perror("acl_set_entry (acl_set_tag_type)");
return ACL_ERROR;
}
perror("acl_set_entry (acl_set_tag_type)");
return ACL_ERROR;
}
- int s_result = acl_set_permset(new_entry, entry_permset);
- if (s_result == ACL_ERROR) {
+ if (acl_set_permset(new_entry, entry_permset) == ACL_ERROR) {
perror("acl_set_entry (acl_set_permset)");
return ACL_ERROR;
}
perror("acl_set_entry (acl_set_permset)");
return ACL_ERROR;
}
- int sq_result = acl_set_qualifier(new_entry, entry_qual);
- if (sq_result == ACL_ERROR) {
+ if (acl_set_qualifier(new_entry, entry_qual) == ACL_ERROR) {
perror("acl_set_entry (acl_set_qualifier)");
return ACL_ERROR;
}
perror("acl_set_entry (acl_set_qualifier)");
return ACL_ERROR;
}
while (ge_result == ACL_SUCCESS) {
acl_tag_t tag = ACL_UNDEFINED_TAG;
while (ge_result == ACL_SUCCESS) {
acl_tag_t tag = ACL_UNDEFINED_TAG;
- int tag_result = acl_get_tag_type(entry, &tag);
- if (tag_result == ACL_ERROR) {
+ if (acl_get_tag_type(entry, &tag) == ACL_ERROR) {
perror("acl_execute_masked (acl_get_tag_type)");
return ACL_ERROR;
}
perror("acl_execute_masked (acl_get_tag_type)");
return ACL_ERROR;
}
execute is specified. */
acl_permset_t permset;
execute is specified. */
acl_permset_t permset;
- int ps_result = acl_get_permset(entry, &permset);
- if (ps_result == ACL_ERROR) {
+ if (acl_get_permset(entry, &permset) == ACL_ERROR) {
perror("acl_execute_masked (acl_get_permset)");
return ACL_ERROR;
}
perror("acl_execute_masked (acl_get_permset)");
return ACL_ERROR;
}
/* The first thing we do is check to see if this is a mask
entry. If it is, we skip it entirely. */
acl_tag_t tag = ACL_UNDEFINED_TAG;
/* The first thing we do is check to see if this is a mask
entry. If it is, we skip it entirely. */
acl_tag_t tag = ACL_UNDEFINED_TAG;
- int tag_result = acl_get_tag_type(entry, &tag);
- if (tag_result == ACL_ERROR) {
+ if (acl_get_tag_type(entry, &tag) == ACL_ERROR) {
perror("any_can_execute_or_dir (acl_get_tag_type)");
result = ACL_ERROR;
goto cleanup;
perror("any_can_execute_or_dir (acl_get_tag_type)");
result = ACL_ERROR;
goto cleanup;
/* Ok, so it's not a mask entry. Check the execute perms. */
acl_permset_t permset;
/* Ok, so it's not a mask entry. Check the execute perms. */
acl_permset_t permset;
- int ps_result = acl_get_permset(entry, &permset);
- if (ps_result == ACL_ERROR) {
+ if (acl_get_permset(entry, &permset) == ACL_ERROR) {
perror("any_can_execute_or_dir (acl_get_permset)");
result = ACL_ERROR;
goto cleanup;
perror("any_can_execute_or_dir (acl_get_permset)");
result = ACL_ERROR;
goto cleanup;
return ACL_ERROR; /* Nothing to clean up in this case. */
}
return ACL_ERROR; /* Nothing to clean up in this case. */
}
- int sf_result = acl_set_file(path, ACL_TYPE_DEFAULT, path_acl);
- if (sf_result == ACL_ERROR) {
+ if (acl_set_file(path, ACL_TYPE_DEFAULT, path_acl) == ACL_ERROR) {
perror("assign_default_acl (acl_set_file)");
result = ACL_ERROR;
}
perror("assign_default_acl (acl_set_file)");
result = ACL_ERROR;
}
- int wipe_result = wipe_acls(fd);
- if (wipe_result == ACL_ERROR) {
+ if (wipe_acls(fd) == ACL_ERROR) {
perror("apply_default_acl (wipe_acls)");
result = ACL_ERROR;
goto cleanup;
perror("apply_default_acl (wipe_acls)");
result = ACL_ERROR;
goto cleanup;
}
/* If it's a directory, inherit the parent's default. */
}
/* If it's a directory, inherit the parent's default. */
- int inherit_result = assign_default_acl(path, defacl);
- if (inherit_result == ACL_ERROR) {
+ if (assign_default_acl(path, defacl) == ACL_ERROR) {
perror("apply_default_acl (assign_default_acl)");
result = ACL_ERROR;
goto cleanup;
perror("apply_default_acl (assign_default_acl)");
result = ACL_ERROR;
goto cleanup;
while (ge_result == ACL_SUCCESS) {
acl_tag_t tag = ACL_UNDEFINED_TAG;
while (ge_result == ACL_SUCCESS) {
acl_tag_t tag = ACL_UNDEFINED_TAG;
- int tag_result = acl_get_tag_type(entry, &tag);
- if (tag_result == ACL_ERROR) {
+ if (acl_get_tag_type(entry, &tag) == ACL_ERROR) {
perror("apply_default_acl (acl_get_tag_type)");
result = ACL_ERROR;
goto cleanup;
perror("apply_default_acl (acl_get_tag_type)");
result = ACL_ERROR;
goto cleanup;
/* We've got an entry/tag from the default ACL. Get its permset. */
acl_permset_t permset;
/* We've got an entry/tag from the default ACL. Get its permset. */
acl_permset_t permset;
- int ps_result = acl_get_permset(entry, &permset);
- if (ps_result == ACL_ERROR) {
+ if (acl_get_permset(entry, &permset) == ACL_ERROR) {
perror("apply_default_acl (acl_get_permset)");
result = ACL_ERROR;
goto cleanup;
perror("apply_default_acl (acl_get_permset)");
result = ACL_ERROR;
goto cleanup;
/* The mask doesn't affect acl_user_obj, acl_group_obj (in
minimal ACLs) or acl_other entries, so if execute should be
masked, we have to do it manually. */
/* The mask doesn't affect acl_user_obj, acl_group_obj (in
minimal ACLs) or acl_other entries, so if execute should be
masked, we have to do it manually. */
- int d_result = acl_delete_perm(permset, ACL_EXECUTE);
- if (d_result == ACL_ERROR) {
+ if (acl_delete_perm(permset, ACL_EXECUTE) == ACL_ERROR) {
perror("apply_default_acl (acl_delete_perm)");
result = ACL_ERROR;
goto cleanup;
}
perror("apply_default_acl (acl_delete_perm)");
result = ACL_ERROR;
goto cleanup;
}
- int sp_result = acl_set_permset(entry, permset);
- if (sp_result == ACL_ERROR) {
+ if (acl_set_permset(entry, permset) == ACL_ERROR) {
perror("apply_default_acl (acl_set_permset)");
result = ACL_ERROR;
goto cleanup;
perror("apply_default_acl (acl_set_permset)");
result = ACL_ERROR;
goto cleanup;
* called right here, we need acl_create_entry() to update the
* value of "acl". To do that, it needs the address of "acl".
*/
* called right here, we need acl_create_entry() to update the
* value of "acl". To do that, it needs the address of "acl".
*/
- int set_result = acl_set_entry(&acl, entry);
- if (set_result == ACL_ERROR) {
+ if (acl_set_entry(&acl, entry) == ACL_ERROR) {
perror("apply_default_acl (acl_set_entry)");
result = ACL_ERROR;
goto cleanup;
perror("apply_default_acl (acl_set_entry)");
result = ACL_ERROR;
goto cleanup;
- int sf_result = acl_set_fd(fd, acl);
- if (sf_result == ACL_ERROR) {
+ if (acl_set_fd(fd, acl) == ACL_ERROR) {
perror("apply_default_acl (acl_set_fd)");
result = ACL_ERROR;
goto cleanup;
perror("apply_default_acl (acl_set_fd)");
result = ACL_ERROR;
goto cleanup;
int info,
struct FTW *ftw) {
int info,
struct FTW *ftw) {
- bool app_result = apply_default_acl(target, false);
- if (app_result) {
+ if (apply_default_acl(target, false)) {
return FTW_CONTINUE;
}
else {
return FTW_CONTINUE;
}
else {
int info,
struct FTW *ftw) {
int info,
struct FTW *ftw) {
- bool app_result = apply_default_acl(target, true);
- if (app_result) {
+ if (apply_default_acl(target, true)) {
return FTW_CONTINUE;
}
else {
return FTW_CONTINUE;
}
else {