2 * Convert GPFS acls to NT acls and vice versa.
4 * Copyright (C) Volker Lendecke, 2006
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #define DBGC_CLASS DBGC_VFS
27 #include "nfs4_acls.h"
29 static void gpfs_dumpacl(int level, struct gpfs_acl *gacl)
34 DEBUG(0, ("gpfs acl is NULL\n"));
38 DEBUG(level, ("gpfs acl: nace: %d, type:%d, version:%d, level:%d, len:%d\n",
39 gacl->acl_nace, gacl->acl_type, gacl->acl_version, gacl->acl_level, gacl->acl_len));
40 for(i=0; i<gacl->acl_nace; i++)
42 struct gpfs_ace_v4 *gace = gacl->ace_v4 + i;
43 DEBUG(level, ("\tace[%d]: type:%d, flags:0x%x, mask:0x%x, iflags:0x%x, who:%u\n",
44 i, gace->aceType, gace->aceFlags, gace->aceMask,
45 gace->aceIFlags, gace->aceWho));
49 static struct gpfs_acl *gpfs_getacl_alloc(const char *fname, gpfs_aclType_t type)
54 TALLOC_CTX *mem_ctx = main_loop_talloc_get();
56 acl = (struct gpfs_acl *)talloc_size(mem_ctx, len);
67 ret = smbd_gpfs_getacl((char *)fname, GPFS_GETACL_STRUCT, acl);
68 if ((ret != 0) && (errno == ENOSPC)) {
69 struct gpfs_acl *new_acl = (struct gpfs_acl *)talloc_size(
70 mem_ctx, acl->acl_len + sizeof(struct gpfs_acl));
71 if (new_acl == NULL) {
76 new_acl->acl_len = acl->acl_len;
77 new_acl->acl_level = acl->acl_level;
78 new_acl->acl_version = acl->acl_version;
79 new_acl->acl_type = acl->acl_type;
82 ret = smbd_gpfs_getacl((char *)fname, GPFS_GETACL_STRUCT, acl);
86 DEBUG(8, ("smbd_gpfs_getacl failed with %s\n",strerror(errno)));
93 static BOOL gpfs_get_nfs4_acl(struct files_struct *fsp, SMB4ACL_T **ppacl, BOOL *pretryPosix)
97 struct gpfs_acl *gacl = NULL;
99 mem_ctx = main_loop_talloc_get();
101 DEBUG(10, ("gpfs_get_nfs4_acl invoked for %s\n", fsp->fsp_name));
103 /* First get the real acl length */
104 gacl = gpfs_getacl_alloc(fsp->fsp_name, GPFS_ACL_TYPE_NFS4);
106 DEBUG(9, ("gpfs_getacl failed for %s with %s\n",
107 fsp->fsp_name, strerror(errno)));
111 if (gacl->acl_type != GPFS_ACL_TYPE_NFS4) {
112 DEBUG(10, ("Got non-nfsv4 acl\n"));
117 *ppacl = smb_create_smb4acl();
119 DEBUG(10, ("len: %d, level: %d, version: %d, nace: %d\n",
120 gacl->acl_len, gacl->acl_level, gacl->acl_version,
123 for (i=0; i<gacl->acl_nace; i++) {
124 struct gpfs_ace_v4 *gace = &gacl->ace_v4[i];
125 SMB_ACE4PROP_T smbace;
126 memset(&smbace, 0, sizeof(SMB4ACE_T));
128 DEBUG(10, ("type: %d, iflags: %x, flags: %x, mask: %x, "
129 "who: %d\n", gace->aceType, gace->aceIFlags,
130 gace->aceFlags, gace->aceMask, gace->aceWho));
132 if (gace->aceIFlags & ACE4_IFLAG_SPECIAL_ID) {
133 smbace.flags |= SMB_ACE4_ID_SPECIAL;
134 switch (gace->aceWho) {
135 case ACE4_SPECIAL_OWNER:
136 smbace.who.special_id = SMB_ACE4_WHO_OWNER;
138 case ACE4_SPECIAL_GROUP:
139 smbace.who.special_id = SMB_ACE4_WHO_GROUP;
141 case ACE4_SPECIAL_EVERYONE:
142 smbace.who.special_id = SMB_ACE4_WHO_EVERYONE;
145 DEBUG(8, ("invalid special gpfs id %d "
146 "ignored\n", gace->aceWho));
147 continue; /* don't add it */
150 if (gace->aceFlags & ACE4_FLAG_GROUP_ID)
151 smbace.who.gid = gace->aceWho;
153 smbace.who.uid = gace->aceWho;
156 smbace.aceType = gace->aceType;
157 smbace.aceFlags = gace->aceFlags;
158 smbace.aceMask = gace->aceMask;
159 smbace.flags = (gace->aceIFlags&ACE4_IFLAG_SPECIAL_ID) ? SMB_ACE4_ID_SPECIAL : 0;
161 smb_add_ace4(*ppacl, &smbace);
167 static size_t gpfsacl_get_nt_acl_common(files_struct *fsp,
168 uint32 security_info, SEC_DESC **ppdesc)
170 SMB4ACL_T *pacl = NULL;
172 BOOL retryPosix = False;
175 result = gpfs_get_nfs4_acl(fsp, &pacl, &retryPosix);
178 DEBUG(10, ("retrying with posix acl...\n"));
179 return get_nt_acl(fsp, security_info, ppdesc);
184 return smb_get_nt_acl_nfs4(fsp, security_info, ppdesc, pacl);
187 size_t gpfsacl_fget_nt_acl(vfs_handle_struct *handle,
188 files_struct *fsp, int fd, uint32 security_info,
191 return gpfsacl_get_nt_acl_common(fsp, security_info, ppdesc);
194 size_t gpfsacl_get_nt_acl(vfs_handle_struct *handle,
195 files_struct *fsp, const char *name,
196 uint32 security_info, SEC_DESC **ppdesc)
198 return gpfsacl_get_nt_acl_common(fsp, security_info, ppdesc);
201 static BOOL gpfsacl_process_smbacl(files_struct *fsp, SMB4ACL_T *smbacl)
204 gpfs_aclLen_t gacl_len;
206 struct gpfs_acl *gacl;
207 TALLOC_CTX *mem_ctx = main_loop_talloc_get();
209 gacl_len = sizeof(struct gpfs_acl) +
210 (smb_get_naces(smbacl)-1)*sizeof(gpfs_ace_v4_t);
212 gacl = talloc_size(mem_ctx, gacl_len);
214 DEBUG(0, ("talloc failed\n"));
219 gacl->acl_len = gacl_len;
221 gacl->acl_version = GPFS_ACL_VERSION_NFS4;
222 gacl->acl_type = GPFS_ACL_TYPE_NFS4;
223 gacl->acl_nace = 0; /* change later... */
225 for (smbace=smb_first_ace4(smbacl); smbace!=NULL; smbace = smb_next_ace4(smbace)) {
226 struct gpfs_ace_v4 *gace = &gacl->ace_v4[gacl->acl_nace];
227 SMB_ACE4PROP_T *aceprop = smb_get_ace4(smbace);
229 gace->aceType = aceprop->aceType;
230 gace->aceFlags = aceprop->aceFlags;
231 gace->aceMask = aceprop->aceMask;
232 gace->aceIFlags = (aceprop->flags&SMB_ACE4_ID_SPECIAL) ? ACE4_IFLAG_SPECIAL_ID : 0;
234 if (aceprop->flags&SMB_ACE4_ID_SPECIAL)
236 switch(aceprop->who.special_id)
238 case SMB_ACE4_WHO_EVERYONE:
239 gace->aceWho = ACE4_SPECIAL_EVERYONE;
241 case SMB_ACE4_WHO_OWNER:
242 gace->aceWho = ACE4_SPECIAL_OWNER;
244 case SMB_ACE4_WHO_GROUP:
245 gace->aceWho = ACE4_SPECIAL_GROUP;
248 DEBUG(8, ("unsupported special_id %d\n", aceprop->who.special_id));
249 continue; /* don't add it !!! */
252 /* just only for the type safety... */
253 if (aceprop->aceFlags&SMB_ACE4_IDENTIFIER_GROUP)
254 gace->aceWho = aceprop->who.gid;
256 gace->aceWho = aceprop->who.uid;
262 ret = smbd_gpfs_putacl(fsp->fsp_name, GPFS_PUTACL_STRUCT, gacl);
264 DEBUG(8, ("gpfs_putacl failed with %s\n", strerror(errno)));
265 gpfs_dumpacl(8, gacl);
269 DEBUG(10, ("gpfs_putacl succeeded\n"));
273 static BOOL gpfsacl_set_nt_acl_internal(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
275 struct gpfs_acl *acl;
278 acl = gpfs_getacl_alloc(fsp->fsp_name, GPFS_ACL_TYPE_ACCESS);
282 if (acl->acl_version&GPFS_ACL_VERSION_NFS4)
284 result = smb_set_nt_acl_nfs4(
285 fsp, security_info_sent, psd,
286 gpfsacl_process_smbacl);
287 } else { /* assume POSIX ACL - by default... */
288 result = set_nt_acl(fsp, security_info_sent, psd);
294 static BOOL gpfsacl_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, uint32 security_info_sent, SEC_DESC *psd)
296 return gpfsacl_set_nt_acl_internal(fsp, security_info_sent, psd);
299 static BOOL gpfsacl_set_nt_acl(vfs_handle_struct *handle, files_struct *fsp, char *name, uint32 security_info_sent, SEC_DESC *psd)
301 return gpfsacl_set_nt_acl_internal(fsp, security_info_sent, psd);
304 static SMB_ACL_T gpfs2smb_acl(const struct gpfs_acl *pacl)
309 result = sys_acl_init(pacl->acl_nace);
310 if (result == NULL) {
315 result->count = pacl->acl_nace;
317 for (i=0; i<pacl->acl_nace; i++) {
318 struct smb_acl_entry *ace = &result->acl[i];
319 const struct gpfs_ace_v1 *g_ace = &pacl->ace_v1[i];
321 DEBUG(10, ("Converting type %d id %lu perm %x\n",
322 (int)g_ace->ace_type, (unsigned long)g_ace->ace_who,
323 (int)g_ace->ace_perm));
325 switch (g_ace->ace_type) {
327 ace->a_type = SMB_ACL_USER;
328 ace->uid = (uid_t)g_ace->ace_who;
330 case GPFS_ACL_USER_OBJ:
331 ace->a_type = SMB_ACL_USER_OBJ;
334 ace->a_type = SMB_ACL_GROUP;
335 ace->gid = (gid_t)g_ace->ace_who;
337 case GPFS_ACL_GROUP_OBJ:
338 ace->a_type = SMB_ACL_GROUP_OBJ;
341 ace->a_type = SMB_ACL_OTHER;
344 ace->a_type = SMB_ACL_MASK;
347 DEBUG(10, ("Got invalid ace_type: %d\n",
355 ace->a_perm |= (g_ace->ace_perm & ACL_PERM_READ) ?
357 ace->a_perm |= (g_ace->ace_perm & ACL_PERM_WRITE) ?
359 ace->a_perm |= (g_ace->ace_perm & ACL_PERM_EXECUTE) ?
362 DEBUGADD(10, ("Converted to %d perm %x\n",
363 ace->a_type, ace->a_perm));
369 static SMB_ACL_T gpfsacl_get_posix_acl(const char *path, gpfs_aclType_t type)
371 struct gpfs_acl *pacl;
372 SMB_ACL_T result = NULL;
374 pacl = gpfs_getacl_alloc(path, type);
377 DEBUG(10, ("gpfs_getacl failed for %s with %s\n",
378 path, strerror(errno)));
385 if (pacl->acl_version != GPFS_ACL_VERSION_POSIX) {
386 DEBUG(10, ("Got acl version %d, expected %d\n",
387 pacl->acl_version, GPFS_ACL_VERSION_POSIX));
392 DEBUG(10, ("len: %d, level: %d, version: %d, nace: %d\n",
393 pacl->acl_len, pacl->acl_level, pacl->acl_version,
396 result = gpfs2smb_acl(pacl);
397 if (result == NULL) {
409 SMB_ACL_T gpfsacl_sys_acl_get_file(vfs_handle_struct *handle,
410 connection_struct *conn,
414 gpfs_aclType_t gpfs_type;
417 case SMB_ACL_TYPE_ACCESS:
418 gpfs_type = GPFS_ACL_TYPE_ACCESS;
420 case SMB_ACL_TYPE_DEFAULT:
421 gpfs_type = GPFS_ACL_TYPE_DEFAULT;
424 DEBUG(0, ("Got invalid type: %d\n", type));
425 smb_panic("exiting");
428 return gpfsacl_get_posix_acl(path_p, gpfs_type);
431 SMB_ACL_T gpfsacl_sys_acl_get_fd(vfs_handle_struct *handle,
435 return gpfsacl_get_posix_acl(fsp->fsp_name, GPFS_ACL_TYPE_ACCESS);
438 static struct gpfs_acl *smb2gpfs_acl(const SMB_ACL_T pacl,
442 struct gpfs_acl *result;
446 gpfs_ace_v1_t ace_v1[1]; /* when GPFS_ACL_VERSION_POSIX */
447 gpfs_ace_v4_t ace_v4[1]; /* when GPFS_ACL_VERSION_NFS4 */
450 DEBUG(10, ("smb2gpfs_acl: Got ACL with %d entries\n", pacl->count));
452 len = sizeof(struct gpfs_acl) - sizeof(union gpfs_ace_union) +
453 (pacl->count)*sizeof(gpfs_ace_v1_t);
455 result = SMB_MALLOC(len);
456 if (result == NULL) {
461 result->acl_len = len;
462 result->acl_level = 0;
463 result->acl_version = GPFS_ACL_VERSION_POSIX;
464 result->acl_type = (type == SMB_ACL_TYPE_DEFAULT) ?
465 GPFS_ACL_TYPE_DEFAULT : GPFS_ACL_TYPE_ACCESS;
466 result->acl_nace = pacl->count;
468 for (i=0; i<pacl->count; i++) {
469 const struct smb_acl_entry *ace = &pacl->acl[i];
470 struct gpfs_ace_v1 *g_ace = &result->ace_v1[i];
472 DEBUG(10, ("Converting type %d perm %x\n",
473 (int)ace->a_type, (int)ace->a_perm));
477 switch(ace->a_type) {
479 g_ace->ace_type = GPFS_ACL_USER;
480 g_ace->ace_who = (gpfs_uid_t)ace->uid;
482 case SMB_ACL_USER_OBJ:
483 g_ace->ace_type = GPFS_ACL_USER_OBJ;
484 g_ace->ace_perm |= ACL_PERM_CONTROL;
488 g_ace->ace_type = GPFS_ACL_GROUP;
489 g_ace->ace_who = (gpfs_uid_t)ace->gid;
491 case SMB_ACL_GROUP_OBJ:
492 g_ace->ace_type = GPFS_ACL_GROUP_OBJ;
496 g_ace->ace_type = GPFS_ACL_MASK;
497 g_ace->ace_perm = 0x8f;
501 g_ace->ace_type = GPFS_ACL_OTHER;
505 DEBUG(10, ("Got invalid ace_type: %d\n", ace->a_type));
511 g_ace->ace_perm |= (ace->a_perm & SMB_ACL_READ) ?
513 g_ace->ace_perm |= (ace->a_perm & SMB_ACL_WRITE) ?
515 g_ace->ace_perm |= (ace->a_perm & SMB_ACL_EXECUTE) ?
516 ACL_PERM_EXECUTE : 0;
518 DEBUGADD(10, ("Converted to %d id %d perm %x\n",
519 g_ace->ace_type, g_ace->ace_who, g_ace->ace_perm));
525 int gpfsacl_sys_acl_set_file(vfs_handle_struct *handle,
526 connection_struct *conn,
531 struct gpfs_acl *gpfs_acl;
534 gpfs_acl = smb2gpfs_acl(theacl, type);
535 if (gpfs_acl == NULL) {
539 result = smbd_gpfs_putacl((char *)name, GPFS_PUTACL_STRUCT, gpfs_acl);
545 int gpfsacl_sys_acl_set_fd(vfs_handle_struct *handle,
547 int fd, SMB_ACL_T theacl)
553 int gpfsacl_sys_acl_delete_def_file(vfs_handle_struct *handle,
554 connection_struct *conn,
561 /* VFS operations structure */
563 static vfs_op_tuple gpfsacl_ops[] =
565 {SMB_VFS_OP(gpfsacl_fget_nt_acl),
566 SMB_VFS_OP_FGET_NT_ACL,
567 SMB_VFS_LAYER_TRANSPARENT},
569 {SMB_VFS_OP(gpfsacl_get_nt_acl),
570 SMB_VFS_OP_GET_NT_ACL,
571 SMB_VFS_LAYER_TRANSPARENT},
573 {SMB_VFS_OP(gpfsacl_fset_nt_acl),
574 SMB_VFS_OP_FSET_NT_ACL,
575 SMB_VFS_LAYER_TRANSPARENT},
577 {SMB_VFS_OP(gpfsacl_set_nt_acl),
578 SMB_VFS_OP_SET_NT_ACL,
579 SMB_VFS_LAYER_TRANSPARENT},
581 {SMB_VFS_OP(gpfsacl_sys_acl_get_file),
582 SMB_VFS_OP_SYS_ACL_GET_FILE,
583 SMB_VFS_LAYER_TRANSPARENT},
585 {SMB_VFS_OP(gpfsacl_sys_acl_get_fd),
586 SMB_VFS_OP_SYS_ACL_GET_FD,
587 SMB_VFS_LAYER_TRANSPARENT},
589 {SMB_VFS_OP(gpfsacl_sys_acl_set_file),
590 SMB_VFS_OP_SYS_ACL_SET_FILE,
591 SMB_VFS_LAYER_TRANSPARENT},
593 {SMB_VFS_OP(gpfsacl_sys_acl_set_fd),
594 SMB_VFS_OP_SYS_ACL_SET_FD,
595 SMB_VFS_LAYER_TRANSPARENT},
597 {SMB_VFS_OP(gpfsacl_sys_acl_delete_def_file),
598 SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
599 SMB_VFS_LAYER_TRANSPARENT},
606 NTSTATUS vfs_gpfsacl_init(void)
608 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "gpfsacl",