/*
* determine ACE permissions.
*/
int
ace_perm_mask(struct acl_perm_type *aclperm, uint32_t *mask)
{
int error;
if (aclperm->perm_style == PERM_TYPE_EMPTY) {
*mask = 0;
return (0);
}
if (aclperm->perm_style == PERM_TYPE_ACE) {
*mask = aclperm->perm_val;
return (0);
}
error = compute_ace_perms(aclperm->perm_str, mask);
if (error) {
acl_error(dgettext(TEXT_DOMAIN,
"Invalid permission(s) '%s' specified\n"),
aclperm->perm_str);
return (EACL_PERM_MASK_ERROR);
}
return (0);
}
void loadImage(const char *image, ACL_Image *mapbuf)
{
HDC hmapdc;
IPicture *ipicture;
IStream *istream;
DWORD filesize = 0, bytes;
OLE_XSIZE_HIMETRIC width;
OLE_YSIZE_HIMETRIC height;
HANDLE file = NULL;
HGLOBAL global = NULL;
LPVOID data = NULL;
ACL_ASSERT_HWND;
file = CreateFileA(image, GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL, NULL);
if(file == INVALID_HANDLE_VALUE)
acl_error("Fail to load image, File not exist");
filesize = GetFileSize(file, NULL);
global = GlobalAlloc(GMEM_MOVEABLE, filesize);
data = GlobalLock(global);
ReadFile(file, data, filesize, &bytes, NULL);
GlobalUnlock(global);
CreateStreamOnHGlobal(global, TRUE, &istream);
OleLoadPicture(istream, filesize, TRUE, &IID_IPicture, (LPVOID*)&ipicture);
ipicture->lpVtbl->get_Width(ipicture, &width);
ipicture->lpVtbl->get_Height(ipicture, &height);
mapbuf->width = (int)(width / 26.45833333333);
mapbuf->height = (int)(height / 26.45833333333);
hmapdc = CreateCompatibleDC(GetDC(g_hWnd));
if (mapbuf->hbitmap != NULL)
DeleteObject(mapbuf->hbitmap);
mapbuf->hbitmap = CreateCompatibleBitmap(GetDC(g_hWnd), mapbuf->width, mapbuf->height);
SelectObject(hmapdc, mapbuf->hbitmap);
ipicture->lpVtbl->Render(ipicture, hmapdc, 0, 0, mapbuf->width, mapbuf->height, 0, height, width, -height, NULL);
ipicture->lpVtbl->Release(ipicture);
istream->lpVtbl->Release(istream);
DeleteDC(hmapdc);
GlobalFree(global);
CloseHandle(file);
}
int
do_set(
const char *path_p,
const struct stat *st,
const seq_t seq)
{
acl_t old_acl = NULL, old_default_acl = NULL;
acl_t acl = NULL, default_acl = NULL;
acl_t *xacl, *old_xacl;
acl_entry_t ent;
cmd_t cmd;
int which_entry;
int errors = 0, error;
char *acl_text;
int acl_modified = 0, default_acl_modified = 0;
int acl_mask_provided = 0, default_acl_mask_provided = 0;
/* Execute the commands in seq (read ACLs on demand) */
error = seq_get_cmd(seq, SEQ_FIRST_CMD, &cmd);
if (error == 0)
return 0;
while (error == 1) {
if (cmd->c_type == ACL_TYPE_ACCESS) {
xacl = &acl;
old_xacl = &old_acl;
acl_modified = 1;
if (cmd->c_tag == ACL_MASK)
acl_mask_provided = 1;
} else {
xacl = &default_acl;
old_xacl = &old_default_acl;
default_acl_modified = 1;
if (cmd->c_tag == ACL_MASK)
default_acl_mask_provided = 1;
}
RETRIEVE_ACL(cmd->c_type);
/* Check for `X', and replace with `x' as appropriate. */
if (cmd->c_perm & CMD_PERM_COND_EXECUTE) {
cmd->c_perm &= ~CMD_PERM_COND_EXECUTE;
if (S_ISDIR(st->st_mode) || has_execute_perms(*xacl))
cmd->c_perm |= CMD_PERM_EXECUTE;
}
switch(cmd->c_cmd) {
case CMD_ENTRY_REPLACE:
ent = find_entry(*xacl, cmd->c_tag, cmd->c_id);
if (!ent) {
if (acl_create_entry(xacl, &ent) != 0)
goto fail;
acl_set_tag_type(ent, cmd->c_tag);
if (cmd->c_id != ACL_UNDEFINED_ID)
acl_set_qualifier(ent,
&cmd->c_id);
}
set_perm(ent, cmd->c_perm, ~cmd->c_perm);
break;
case CMD_ENTRY_ADD:
ent = find_entry(*xacl, cmd->c_tag, cmd->c_id);
if (ent)
set_perm(ent, cmd->c_perm, 0);
break;
case CMD_ENTRY_SUBTRACT:
ent = find_entry(*xacl, cmd->c_tag, cmd->c_id);
if (ent)
set_perm(ent, 0, cmd->c_perm);
break;
case CMD_REMOVE_ENTRY:
ent = find_entry(*xacl, cmd->c_tag, cmd->c_id);
if (ent)
acl_delete_entry(*xacl, ent);
else
/* ignore */;
break;
case CMD_REMOVE_EXTENDED_ACL:
remove_extended_entries(acl);
break;
case CMD_REMOVE_ACL:
acl_free(*xacl);
*xacl = acl_init(5);
if (!*xacl)
goto fail;
break;
default:
errno = EINVAL;
goto fail;
}
error = seq_get_cmd(seq, SEQ_NEXT_CMD, &cmd);
}
if (error < 0)
goto fail;
/* Try to fill in missing entries */
if (default_acl && acl_entries(default_acl) != 0) {
xacl = &acl;
old_xacl = &old_acl;
if (!find_entry(default_acl, ACL_USER_OBJ, ACL_UNDEFINED_ID)) {
if (!acl)
RETRIEVE_ACL(ACL_TYPE_ACCESS);
clone_entry(acl, ACL_USER_OBJ,
&default_acl, ACL_USER_OBJ);
}
if (!find_entry(default_acl, ACL_GROUP_OBJ, ACL_UNDEFINED_ID)) {
if (!acl)
RETRIEVE_ACL(ACL_TYPE_ACCESS);
clone_entry(acl, ACL_GROUP_OBJ,
&default_acl, ACL_GROUP_OBJ);
}
if (!find_entry(default_acl, ACL_OTHER, ACL_UNDEFINED_ID)) {
if (!acl)
RETRIEVE_ACL(ACL_TYPE_ACCESS);
clone_entry(acl, ACL_OTHER,
&default_acl, ACL_OTHER);
}
}
/* update mask entries and check if ACLs are valid */
if (acl && acl_modified) {
if (acl_equiv_mode(acl, NULL) != 0) {
if (!acl_mask_provided &&
!find_entry(acl, ACL_MASK, ACL_UNDEFINED_ID))
clone_entry(acl, ACL_GROUP_OBJ,
&acl, ACL_MASK);
if (opt_recalculate != -1 &&
(!acl_mask_provided || opt_recalculate == 1))
acl_calc_mask(&acl);
}
error = acl_check(acl, &which_entry);
if (error < 0)
goto fail;
if (error > 0) {
acl_text = acl_to_any_text(acl, NULL, ',', 0);
fprintf(stderr, gettext("%s: %s: Malformed access ACL "
"`%s': %s at entry %d\n"), progname, path_p,
acl_text, acl_error(error), which_entry+1);
acl_free(acl_text);
errors++;
goto cleanup;
}
}
if (default_acl && acl_entries(default_acl) != 0 &&
default_acl_modified) {
if (acl_equiv_mode(default_acl, NULL) != 0) {
if (!default_acl_mask_provided &&
!find_entry(default_acl,ACL_MASK,ACL_UNDEFINED_ID))
clone_entry(default_acl, ACL_GROUP_OBJ,
&default_acl, ACL_MASK);
if (opt_recalculate != -1 &&
(!default_acl_mask_provided ||
opt_recalculate == 1))
acl_calc_mask(&default_acl);
}
error = acl_check(default_acl, &which_entry);
if (error < 0)
goto fail;
if (error > 0) {
acl_text = acl_to_any_text(default_acl, NULL, ',', 0);
fprintf(stderr, gettext("%s: %s: Malformed default ACL "
"`%s': %s at entry %d\n"),
progname, path_p, acl_text,
acl_error(error), which_entry+1);
acl_free(acl_text);
errors++;
goto cleanup;
}
}
/* Only directores can have default ACLs */
if (default_acl && !S_ISDIR(st->st_mode) && opt_recursive) {
/* In recursive mode, ignore default ACLs for files */
acl_free(default_acl);
default_acl = NULL;
}
/* check which ACLs have changed */
if (acl && old_acl && acl_cmp(old_acl, acl) == 0) {
acl_free(acl);
acl = NULL;
}
if ((default_acl && old_default_acl &&
acl_cmp(old_default_acl, default_acl) == 0)) {
acl_free(default_acl);
default_acl = NULL;
}
/* update the file system */
if (opt_test) {
print_test(stdout, path_p, st,
acl, default_acl);
goto cleanup;
}
if (acl) {
if (acl_set_file(path_p, ACL_TYPE_ACCESS, acl) != 0) {
if (errno == ENOSYS || errno == ENOTSUP) {
int saved_errno = errno;
mode_t mode;
if (acl_equiv_mode(acl, &mode) != 0) {
errno = saved_errno;
goto fail;
} else if (chmod(path_p, mode) != 0)
goto fail;
} else
goto fail;
}
}
if (default_acl) {
if (S_ISDIR(st->st_mode)) {
if (acl_entries(default_acl) == 0) {
if (acl_delete_def_file(path_p) != 0 &&
errno != ENOSYS && errno != ENOTSUP)
goto fail;
} else {
if (acl_set_file(path_p, ACL_TYPE_DEFAULT,
default_acl) != 0)
goto fail;
}
} else {
if (acl_entries(default_acl) != 0) {
fprintf(stderr, gettext(
"%s: %s: Only directories "
"can have default ACLs\n"),
progname, path_p);
errors++;
goto cleanup;
}
}
}
error = 0;
cleanup:
if (acl)
acl_free(acl);
if (old_acl)
acl_free(old_acl);
if (default_acl)
acl_free(default_acl);
if (old_default_acl)
acl_free(old_default_acl);
return errors;
fail:
fprintf(stderr, "%s: %s: %s\n", progname, path_p, strerror(errno));
errors++;
goto cleanup;
}
int
main(int argc, char *argv[])
{
char *file;
int switch_flag = 0; /* ensure only one switch is used */
int args_required = 2;
int failed = 0; /* exit status */
int c; /* For use by getopt(3) */
int dflag = 0; /* a Default ACL is desired */
int bflag = 0; /* a both ACLs are desired */
int Rflag = 0; /* set to true to remove an acl */
int Dflag = 0; /* set to true to remove default acls */
int Bflag = 0; /* set to true to remove both acls */
int lflag = 0; /* set to true to list acls */
acl_t acl = NULL; /* File ACL */
acl_t dacl = NULL; /* Directory Default ACL */
program = basename(argv[0]);
setlocale(LC_CTYPE, "");
setlocale(LC_MESSAGES, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
/* parse arguments */
while ((c = getopt(argc, argv, "bdlRDBr")) != -1) {
if (switch_flag)
usage();
switch_flag = 1;
switch (c) {
case 'b':
bflag = 1;
args_required = 3;
break;
case 'd':
dflag = 1;
args_required = 2;
break;
case 'R':
Rflag = 1;
args_required = 1;
break;
case 'D':
Dflag = 1;
args_required = 1;
break;
case 'B':
Bflag = 1;
args_required = 1;
break;
case 'l':
lflag = 1;
args_required = 1;
break;
case 'r':
rflag = 1;
args_required = 1;
break;
default:
usage();
break;
}
}
/* if not enough arguments quit */
if ((argc - optind) < args_required)
usage();
/* list the acls */
if (lflag) {
for (; optind < argc; optind++) {
file = argv[optind];
if (!list_acl(file))
failed++;
}
return(failed);
}
/* remove the acls */
if (Rflag || Dflag || Bflag) {
for (; optind < argc; optind++) {
file = argv[optind];
if (!Dflag &&
(acl_delete_file(file, ACL_TYPE_ACCESS) == -1)) {
fprintf(stderr, _(
"%s: error removing access acl on \"%s\": %s\n"),
program, file, strerror(errno));
failed++;
}
if (!Rflag &&
(acl_delete_file(file, ACL_TYPE_DEFAULT) == -1)) {
fprintf(stderr, _(
"%s: error removing default acl on \"%s\": %s\n"),
program, file, strerror(errno));
failed++;
}
}
return(failed);
}
/* file access acl */
if (! dflag) {
acl = acl_from_text(argv[optind]);
failed = acl_check(acl, &c);
if (failed < 0) {
fprintf(stderr, "%s: %s - %s\n",
program, argv[optind], strerror(errno));
return 1;
}
else if (failed > 0) {
fprintf(stderr, _(
"%s: access ACL '%s': %s at entry %d\n"),
program, argv[optind], acl_error(failed), c);
return 1;
}
optind++;
}
/* directory default acl */
if (bflag || dflag) {
dacl = acl_from_text(argv[optind]);
failed = acl_check(dacl, &c);
if (failed < 0) {
fprintf(stderr, "%s: %s - %s\n",
program, argv[optind], strerror(errno));
return 1;
}
else if (failed > 0) {
fprintf(stderr, _(
"%s: access ACL '%s': %s at entry %d\n"),
program, argv[optind], acl_error(failed), c);
return 1;
}
optind++;
}
/* place acls on files */
for (; optind < argc; optind++)
failed += set_acl(acl, dacl, argv[optind]);
if (acl)
acl_free(acl);
if (dacl)
acl_free(dacl);
return(failed);
}
