Support getting gpfs birthtime
[ira/wip.git] / source3 / modules / vfs_gpfs.c
1 /*
2    Unix SMB/CIFS implementation.
3    Wrap gpfs calls in vfs functions.
4
5    Copyright (C) Christian Ambach <cambach1@de.ibm.com> 2006
6
7    Major code contributions by Chetan Shringarpure <chetan.sh@in.ibm.com>
8                             and Gomati Mohanan <gomati.mohanan@in.ibm.com>
9
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "includes.h"
25
26 #undef DBGC_CLASS
27 #define DBGC_CLASS DBGC_VFS
28
29 #include <gpfs_gpl.h>
30 #include "nfs4_acls.h"
31 #include "vfs_gpfs.h"
32
33 static int vfs_gpfs_kernel_flock(vfs_handle_struct *handle, files_struct *fsp, 
34                                  uint32 share_mode)
35 {
36
37         START_PROFILE(syscall_kernel_flock);
38
39         kernel_flock(fsp->fh->fd, share_mode);
40
41         if (!set_gpfs_sharemode(fsp, fsp->access_mask, fsp->share_access)) {
42
43                 return -1;
44
45         }
46
47         END_PROFILE(syscall_kernel_flock);
48
49         return 0;
50 }
51
52 static int vfs_gpfs_close(vfs_handle_struct *handle, files_struct *fsp)
53 {
54         if ((fsp->fh != NULL) && (fsp->fh->fd != -1)) {
55                 set_gpfs_sharemode(fsp, 0, 0);
56         }
57
58         return SMB_VFS_NEXT_CLOSE(handle, fsp);
59 }
60
61 static int vfs_gpfs_setlease(vfs_handle_struct *handle, files_struct *fsp, 
62                              int leasetype)
63 {
64         int ret;
65
66         START_PROFILE(syscall_linux_setlease);
67
68         if ( linux_set_lease_sighandler(fsp->fh->fd) == -1)
69                 return -1;
70
71         ret = set_gpfs_lease(fsp->fh->fd,leasetype);
72
73         if ( ret < 0 ) {
74                 /* This must have come from GPFS not being available */
75                 /* or some other error, hence call the default */
76                 ret = linux_setlease(fsp->fh->fd, leasetype);
77         }
78
79         END_PROFILE(syscall_linux_setlease);
80
81         return ret;
82 }
83
84 static int vfs_gpfs_get_real_filename(struct vfs_handle_struct *handle,
85                                       const char *path,
86                                       const char *name,
87                                       TALLOC_CTX *mem_ctx,
88                                       char **found_name)
89 {
90         int result;
91         char *full_path;
92         char real_pathname[PATH_MAX+1];
93         int buflen;
94
95         full_path = talloc_asprintf(talloc_tos(), "%s/%s", path, name);
96         if (full_path == NULL) {
97                 errno = ENOMEM;
98                 return -1;
99         }
100
101         buflen = sizeof(real_pathname) - 1;
102
103         result = smbd_gpfs_get_realfilename_path(full_path, real_pathname,
104                                                  &buflen);
105
106         TALLOC_FREE(full_path);
107
108         if ((result == -1) && (errno == ENOSYS)) {
109                 return SMB_VFS_NEXT_GET_REAL_FILENAME(
110                         handle, path, name, mem_ctx, found_name);
111         }
112
113         if (result == -1) {
114                 DEBUG(10, ("smbd_gpfs_get_realfilename_path returned %s\n",
115                            strerror(errno)));
116                 return -1;
117         }
118
119         /*
120          * GPFS does not necessarily null-terminate the returned path
121          * but instead returns the buffer length in buflen.
122          */
123
124         if (buflen < sizeof(real_pathname)) {
125                 real_pathname[buflen] = '\0';
126         } else {
127                 real_pathname[sizeof(real_pathname)-1] = '\0';
128         }
129
130         DEBUG(10, ("smbd_gpfs_get_realfilename_path: %s/%s -> %s\n",
131                    path, name, real_pathname));
132
133         name = strrchr_m(real_pathname, '/');
134         if (name == NULL) {
135                 errno = ENOENT;
136                 return -1;
137         }
138
139         *found_name = talloc_strdup(mem_ctx, name+1);
140         if (*found_name == NULL) {
141                 errno = ENOMEM;
142                 return -1;
143         }
144
145         return 0;
146 }
147
148 static void gpfs_dumpacl(int level, struct gpfs_acl *gacl)
149 {
150         int     i;
151         if (gacl==NULL)
152         {
153                 DEBUG(0, ("gpfs acl is NULL\n"));
154                 return;
155         }
156
157         DEBUG(level, ("gpfs acl: nace: %d, type:%d, version:%d, level:%d, len:%d\n",
158                 gacl->acl_nace, gacl->acl_type, gacl->acl_version, gacl->acl_level, gacl->acl_len));
159         for(i=0; i<gacl->acl_nace; i++)
160         {
161                 struct gpfs_ace_v4 *gace = gacl->ace_v4 + i;
162                 DEBUG(level, ("\tace[%d]: type:%d, flags:0x%x, mask:0x%x, iflags:0x%x, who:%u\n",
163                         i, gace->aceType, gace->aceFlags, gace->aceMask,
164                         gace->aceIFlags, gace->aceWho));
165         }
166 }
167
168 static struct gpfs_acl *gpfs_getacl_alloc(const char *fname, gpfs_aclType_t type)
169 {
170         struct gpfs_acl *acl;
171         size_t len = 200;
172         int ret;
173         TALLOC_CTX *mem_ctx = talloc_tos();
174
175         acl = (struct gpfs_acl *)TALLOC_SIZE(mem_ctx, len);
176         if (acl == NULL) {
177                 errno = ENOMEM;
178                 return NULL;
179         }
180
181         acl->acl_len = len;
182         acl->acl_level = 0;
183         acl->acl_version = 0;
184         acl->acl_type = type;
185
186         ret = smbd_gpfs_getacl((char *)fname, GPFS_GETACL_STRUCT | GPFS_ACL_SAMBA, acl);
187         if ((ret != 0) && (errno == ENOSPC)) {
188                 struct gpfs_acl *new_acl = (struct gpfs_acl *)TALLOC_SIZE(
189                         mem_ctx, acl->acl_len + sizeof(struct gpfs_acl));
190                 if (new_acl == NULL) {
191                         errno = ENOMEM;
192                         return NULL;
193                 }
194
195                 new_acl->acl_len = acl->acl_len;
196                 new_acl->acl_level = acl->acl_level;
197                 new_acl->acl_version = acl->acl_version;
198                 new_acl->acl_type = acl->acl_type;
199                 acl = new_acl;
200
201                 ret = smbd_gpfs_getacl((char *)fname, GPFS_GETACL_STRUCT | GPFS_ACL_SAMBA, acl);
202         }
203         if (ret != 0)
204         {
205                 DEBUG(8, ("smbd_gpfs_getacl failed with %s\n",strerror(errno)));
206                 return NULL;
207         }
208
209         return acl;
210 }
211
212 /* Tries to get nfs4 acls and returns SMB ACL allocated.
213  * On failure returns 1 if it got non-NFSv4 ACL to prompt 
214  * retry with POSIX ACL checks.
215  * On failure returns -1 if there is system (GPFS) error, check errno.
216  * Returns 0 on success
217  */
218 static int gpfs_get_nfs4_acl(const char *fname, SMB4ACL_T **ppacl)
219 {
220         int i;
221         struct gpfs_acl *gacl = NULL;
222         DEBUG(10, ("gpfs_get_nfs4_acl invoked for %s\n", fname));
223
224         /* First get the real acl length */
225         gacl = gpfs_getacl_alloc(fname, 0);
226         if (gacl == NULL) {
227                 DEBUG(9, ("gpfs_getacl failed for %s with %s\n",
228                            fname, strerror(errno)));
229                 return -1;
230         }
231
232         if (gacl->acl_type != GPFS_ACL_TYPE_NFS4) {
233                 DEBUG(10, ("Got non-nfsv4 acl\n"));
234                 /* Retry with POSIX ACLs check */
235                 return 1;
236         }
237
238         *ppacl = smb_create_smb4acl();
239
240         DEBUG(10, ("len: %d, level: %d, version: %d, nace: %d\n",
241                    gacl->acl_len, gacl->acl_level, gacl->acl_version,
242                    gacl->acl_nace));
243
244         for (i=0; i<gacl->acl_nace; i++) {
245                 struct gpfs_ace_v4 *gace = &gacl->ace_v4[i];
246                 SMB_ACE4PROP_T smbace;
247                 DEBUG(10, ("type: %d, iflags: %x, flags: %x, mask: %x, "
248                            "who: %d\n", gace->aceType, gace->aceIFlags,
249                            gace->aceFlags, gace->aceMask, gace->aceWho));
250
251                 ZERO_STRUCT(smbace);
252                 if (gace->aceIFlags & ACE4_IFLAG_SPECIAL_ID) {
253                         smbace.flags |= SMB_ACE4_ID_SPECIAL;
254                         switch (gace->aceWho) {
255                         case ACE4_SPECIAL_OWNER:
256                                 smbace.who.special_id = SMB_ACE4_WHO_OWNER;
257                                 break;
258                         case ACE4_SPECIAL_GROUP:
259                                 smbace.who.special_id = SMB_ACE4_WHO_GROUP;
260                                 break;
261                         case ACE4_SPECIAL_EVERYONE:
262                                 smbace.who.special_id = SMB_ACE4_WHO_EVERYONE;
263                                 break;
264                         default:
265                                 DEBUG(8, ("invalid special gpfs id %d "
266                                           "ignored\n", gace->aceWho));
267                                 continue; /* don't add it */
268                         }
269                 } else {
270                         if (gace->aceFlags & ACE4_FLAG_GROUP_ID)
271                                 smbace.who.gid = gace->aceWho;
272                         else
273                                 smbace.who.uid = gace->aceWho;
274                 }
275
276                 /* remove redundent deny entries */
277                 if (i > 0 && gace->aceType == SMB_ACE4_ACCESS_DENIED_ACE_TYPE) {
278                         struct gpfs_ace_v4 *prev = &gacl->ace_v4[i-1];
279                         if (prev->aceType == SMB_ACE4_ACCESS_ALLOWED_ACE_TYPE &&
280                             prev->aceFlags == gace->aceFlags &&
281                             prev->aceIFlags == gace->aceIFlags &&
282                             (gace->aceMask & prev->aceMask) == 0 &&
283                             gace->aceWho == prev->aceWho) {
284                                 /* its redundent - skip it */
285                                 continue;
286                         }                                                
287                 }
288
289                 smbace.aceType = gace->aceType;
290                 smbace.aceFlags = gace->aceFlags;
291                 smbace.aceMask = gace->aceMask;
292                 smb_add_ace4(*ppacl, &smbace);
293         }
294
295         return 0;
296 }
297
298 static NTSTATUS gpfsacl_fget_nt_acl(vfs_handle_struct *handle,
299         files_struct *fsp, uint32 security_info,
300         SEC_DESC **ppdesc)
301 {
302         SMB4ACL_T *pacl = NULL;
303         int     result;
304
305         *ppdesc = NULL;
306         result = gpfs_get_nfs4_acl(fsp->fsp_name, &pacl);
307
308         if (result == 0)
309                 return smb_fget_nt_acl_nfs4(fsp, security_info, ppdesc, pacl);
310
311         if (result > 0) {
312                 DEBUG(10, ("retrying with posix acl...\n"));
313                 return posix_fget_nt_acl(fsp, security_info, ppdesc);
314         }
315
316         /* GPFS ACL was not read, something wrong happened, error code is set in errno */
317         return map_nt_error_from_unix(errno);
318 }
319
320 static NTSTATUS gpfsacl_get_nt_acl(vfs_handle_struct *handle,
321         const char *name,
322         uint32 security_info, SEC_DESC **ppdesc)
323 {
324         SMB4ACL_T *pacl = NULL;
325         int     result;
326
327         *ppdesc = NULL;
328         result = gpfs_get_nfs4_acl(name, &pacl);
329
330         if (result == 0)
331                 return smb_get_nt_acl_nfs4(handle->conn, name, security_info, ppdesc, pacl);
332
333         if (result > 0) {
334                 DEBUG(10, ("retrying with posix acl...\n"));
335                 return posix_get_nt_acl(handle->conn, name, security_info, ppdesc);
336         }
337
338         /* GPFS ACL was not read, something wrong happened, error code is set in errno */
339         return map_nt_error_from_unix(errno);
340 }
341
342 static bool gpfsacl_process_smbacl(files_struct *fsp, SMB4ACL_T *smbacl)
343 {
344         int ret;
345         gpfs_aclLen_t gacl_len;
346         SMB4ACE_T       *smbace;
347         struct gpfs_acl *gacl;
348         TALLOC_CTX *mem_ctx  = talloc_tos();
349
350         gacl_len = sizeof(struct gpfs_acl) +
351                 (smb_get_naces(smbacl)-1)*sizeof(gpfs_ace_v4_t);
352
353         gacl = (struct gpfs_acl *)TALLOC_SIZE(mem_ctx, gacl_len);
354         if (gacl == NULL) {
355                 DEBUG(0, ("talloc failed\n"));
356                 errno = ENOMEM;
357                 return False;
358         }
359
360         gacl->acl_len = gacl_len;
361         gacl->acl_level = 0;
362         gacl->acl_version = GPFS_ACL_VERSION_NFS4;
363         gacl->acl_type = GPFS_ACL_TYPE_NFS4;
364         gacl->acl_nace = 0; /* change later... */
365
366         for (smbace=smb_first_ace4(smbacl); smbace!=NULL; smbace = smb_next_ace4(smbace)) {
367                 struct gpfs_ace_v4 *gace = &gacl->ace_v4[gacl->acl_nace];
368                 SMB_ACE4PROP_T  *aceprop = smb_get_ace4(smbace);
369
370                 gace->aceType = aceprop->aceType;
371                 gace->aceFlags = aceprop->aceFlags;
372                 gace->aceMask = aceprop->aceMask;
373
374                 /*
375                  * GPFS can't distinguish between WRITE and APPEND on
376                  * files, so one being set without the other is an
377                  * error. Sorry for the many ()'s :-)
378                  */
379
380                 if (!fsp->is_directory
381                     &&
382                     ((((gace->aceMask & ACE4_MASK_WRITE) == 0)
383                       && ((gace->aceMask & ACE4_MASK_APPEND) != 0))
384                      ||
385                      (((gace->aceMask & ACE4_MASK_WRITE) != 0)
386                       && ((gace->aceMask & ACE4_MASK_APPEND) == 0)))
387                     &&
388                     lp_parm_bool(fsp->conn->params->service, "gpfs",
389                                  "merge_writeappend", True)) {
390                         DEBUG(2, ("vfs_gpfs.c: file [%s]: ACE contains "
391                                   "WRITE^APPEND, setting WRITE|APPEND\n",
392                                   fsp->fsp_name));
393                         gace->aceMask |= ACE4_MASK_WRITE|ACE4_MASK_APPEND;
394                 }
395
396                 gace->aceIFlags = (aceprop->flags&SMB_ACE4_ID_SPECIAL) ? ACE4_IFLAG_SPECIAL_ID : 0;
397
398                 if (aceprop->flags&SMB_ACE4_ID_SPECIAL)
399                 {
400                         switch(aceprop->who.special_id)
401                         {
402                         case SMB_ACE4_WHO_EVERYONE:
403                                 gace->aceWho = ACE4_SPECIAL_EVERYONE;
404                                 break;
405                         case SMB_ACE4_WHO_OWNER:
406                                 gace->aceWho = ACE4_SPECIAL_OWNER;
407                                 break;
408                         case SMB_ACE4_WHO_GROUP:
409                                 gace->aceWho = ACE4_SPECIAL_GROUP;
410                                 break;
411                         default:
412                                 DEBUG(8, ("unsupported special_id %d\n", aceprop->who.special_id));
413                                 continue; /* don't add it !!! */
414                         }
415                 } else {
416                         /* just only for the type safety... */
417                         if (aceprop->aceFlags&SMB_ACE4_IDENTIFIER_GROUP)
418                                 gace->aceWho = aceprop->who.gid;
419                         else
420                                 gace->aceWho = aceprop->who.uid;
421                 }
422
423                 gacl->acl_nace++;
424         }
425
426         ret = smbd_gpfs_putacl(fsp->fsp_name, GPFS_PUTACL_STRUCT | GPFS_ACL_SAMBA, gacl);
427         if (ret != 0) {
428                 DEBUG(8, ("gpfs_putacl failed with %s\n", strerror(errno)));
429                 gpfs_dumpacl(8, gacl);
430                 return False;
431         }
432
433         DEBUG(10, ("gpfs_putacl succeeded\n"));
434         return True;
435 }
436
437 static NTSTATUS gpfsacl_set_nt_acl_internal(files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
438 {
439         struct gpfs_acl *acl;
440         NTSTATUS result = NT_STATUS_ACCESS_DENIED;
441
442         acl = gpfs_getacl_alloc(fsp->fsp_name, 0);
443         if (acl == NULL)
444                 return result;
445
446         if (acl->acl_version&GPFS_ACL_VERSION_NFS4)
447         {
448                 result = smb_set_nt_acl_nfs4(
449                         fsp, security_info_sent, psd,
450                         gpfsacl_process_smbacl);
451         } else { /* assume POSIX ACL - by default... */
452                 result = set_nt_acl(fsp, security_info_sent, psd);
453         }
454
455         return result;
456 }
457
458 static NTSTATUS gpfsacl_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
459 {
460         return gpfsacl_set_nt_acl_internal(fsp, security_info_sent, psd);
461 }
462
463 static SMB_ACL_T gpfs2smb_acl(const struct gpfs_acl *pacl)
464 {
465         SMB_ACL_T result;
466         int i;
467
468         result = sys_acl_init(pacl->acl_nace);
469         if (result == NULL) {
470                 errno = ENOMEM;
471                 return NULL;
472         }
473
474         result->count = pacl->acl_nace;
475
476         for (i=0; i<pacl->acl_nace; i++) {
477                 struct smb_acl_entry *ace = &result->acl[i];
478                 const struct gpfs_ace_v1 *g_ace = &pacl->ace_v1[i];
479
480                 DEBUG(10, ("Converting type %d id %lu perm %x\n",
481                            (int)g_ace->ace_type, (unsigned long)g_ace->ace_who,
482                            (int)g_ace->ace_perm));
483
484                 switch (g_ace->ace_type) {
485                 case GPFS_ACL_USER:
486                         ace->a_type = SMB_ACL_USER;
487                         ace->uid = (uid_t)g_ace->ace_who;
488                         break;
489                 case GPFS_ACL_USER_OBJ:
490                         ace->a_type = SMB_ACL_USER_OBJ;
491                         break;
492                 case GPFS_ACL_GROUP:
493                         ace->a_type = SMB_ACL_GROUP;
494                         ace->gid = (gid_t)g_ace->ace_who;
495                         break;
496                 case GPFS_ACL_GROUP_OBJ:
497                         ace->a_type = SMB_ACL_GROUP_OBJ;
498                         break;
499                 case GPFS_ACL_OTHER:
500                         ace->a_type = SMB_ACL_OTHER;
501                         break;
502                 case GPFS_ACL_MASK:
503                         ace->a_type = SMB_ACL_MASK;
504                         break;
505                 default:
506                         DEBUG(10, ("Got invalid ace_type: %d\n",
507                                    g_ace->ace_type));
508                         errno = EINVAL;
509                         SAFE_FREE(result);
510                         return NULL;
511                 }
512
513                 ace->a_perm = 0;
514                 ace->a_perm |= (g_ace->ace_perm & ACL_PERM_READ) ?
515                         SMB_ACL_READ : 0;
516                 ace->a_perm |= (g_ace->ace_perm & ACL_PERM_WRITE) ?
517                         SMB_ACL_WRITE : 0;
518                 ace->a_perm |= (g_ace->ace_perm & ACL_PERM_EXECUTE) ?
519                         SMB_ACL_EXECUTE : 0;
520
521                 DEBUGADD(10, ("Converted to %d perm %x\n",
522                               ace->a_type, ace->a_perm));
523         }
524
525         return result;
526 }
527
528 static SMB_ACL_T gpfsacl_get_posix_acl(const char *path, gpfs_aclType_t type)
529 {
530         struct gpfs_acl *pacl;
531         SMB_ACL_T result = NULL;
532
533         pacl = gpfs_getacl_alloc(path, type);
534
535         if (pacl == NULL) {
536                 DEBUG(10, ("gpfs_getacl failed for %s with %s\n",
537                            path, strerror(errno)));
538                 if (errno == 0) {
539                         errno = EINVAL;
540                 }
541                 goto done;
542         }
543
544         if (pacl->acl_version != GPFS_ACL_VERSION_POSIX) {
545                 DEBUG(10, ("Got acl version %d, expected %d\n",
546                            pacl->acl_version, GPFS_ACL_VERSION_POSIX));
547                 errno = EINVAL;
548                 goto done;
549         }
550
551         DEBUG(10, ("len: %d, level: %d, version: %d, nace: %d\n",
552                    pacl->acl_len, pacl->acl_level, pacl->acl_version,
553                    pacl->acl_nace));
554
555         result = gpfs2smb_acl(pacl);
556         if (result == NULL) {
557                 goto done;
558         }
559
560  done:
561
562         if (errno != 0) {
563                 SAFE_FREE(result);
564         }
565         return result;  
566 }
567
568 static SMB_ACL_T gpfsacl_sys_acl_get_file(vfs_handle_struct *handle,
569                                           const char *path_p,
570                                           SMB_ACL_TYPE_T type)
571 {
572         gpfs_aclType_t gpfs_type;
573
574         switch(type) {
575         case SMB_ACL_TYPE_ACCESS:
576                 gpfs_type = GPFS_ACL_TYPE_ACCESS;
577                 break;
578         case SMB_ACL_TYPE_DEFAULT:
579                 gpfs_type = GPFS_ACL_TYPE_DEFAULT;
580                 break;
581         default:
582                 DEBUG(0, ("Got invalid type: %d\n", type));
583                 smb_panic("exiting");
584         }
585
586         return gpfsacl_get_posix_acl(path_p, gpfs_type);
587 }
588
589 static SMB_ACL_T gpfsacl_sys_acl_get_fd(vfs_handle_struct *handle,
590                                         files_struct *fsp)
591 {
592         return gpfsacl_get_posix_acl(fsp->fsp_name, GPFS_ACL_TYPE_ACCESS);
593 }
594
595 static struct gpfs_acl *smb2gpfs_acl(const SMB_ACL_T pacl,
596                                      SMB_ACL_TYPE_T type)
597 {
598         gpfs_aclLen_t len;
599         struct gpfs_acl *result;
600         int i;
601         union gpfs_ace_union
602         {
603                 gpfs_ace_v1_t  ace_v1[1]; /* when GPFS_ACL_VERSION_POSIX */
604                 gpfs_ace_v4_t  ace_v4[1]; /* when GPFS_ACL_VERSION_NFS4  */
605         };
606
607         DEBUG(10, ("smb2gpfs_acl: Got ACL with %d entries\n", pacl->count));
608
609         len = sizeof(struct gpfs_acl) - sizeof(union gpfs_ace_union) +
610                 (pacl->count)*sizeof(gpfs_ace_v1_t);
611
612         result = (struct gpfs_acl *)SMB_MALLOC(len);
613         if (result == NULL) {
614                 errno = ENOMEM;
615                 return result;
616         }
617
618         result->acl_len = len;
619         result->acl_level = 0;
620         result->acl_version = GPFS_ACL_VERSION_POSIX;
621         result->acl_type = (type == SMB_ACL_TYPE_DEFAULT) ?
622                 GPFS_ACL_TYPE_DEFAULT : GPFS_ACL_TYPE_ACCESS;
623         result->acl_nace = pacl->count;
624
625         for (i=0; i<pacl->count; i++) {
626                 const struct smb_acl_entry *ace = &pacl->acl[i];
627                 struct gpfs_ace_v1 *g_ace = &result->ace_v1[i];
628
629                 DEBUG(10, ("Converting type %d perm %x\n",
630                            (int)ace->a_type, (int)ace->a_perm));
631
632                 g_ace->ace_perm = 0;
633
634                 switch(ace->a_type) {
635                 case SMB_ACL_USER:
636                         g_ace->ace_type = GPFS_ACL_USER;
637                         g_ace->ace_who = (gpfs_uid_t)ace->uid;
638                         break;
639                 case SMB_ACL_USER_OBJ:
640                         g_ace->ace_type = GPFS_ACL_USER_OBJ;
641                         g_ace->ace_perm |= ACL_PERM_CONTROL;
642                         g_ace->ace_who = 0;
643                         break;
644                 case SMB_ACL_GROUP:
645                         g_ace->ace_type = GPFS_ACL_GROUP;
646                         g_ace->ace_who = (gpfs_uid_t)ace->gid;
647                         break;
648                 case SMB_ACL_GROUP_OBJ:
649                         g_ace->ace_type = GPFS_ACL_GROUP_OBJ;
650                         g_ace->ace_who = 0;
651                         break;
652                 case SMB_ACL_MASK:
653                         g_ace->ace_type = GPFS_ACL_MASK;
654                         g_ace->ace_perm = 0x8f;
655                         g_ace->ace_who = 0;
656                         break;
657                 case SMB_ACL_OTHER:
658                         g_ace->ace_type = GPFS_ACL_OTHER;
659                         g_ace->ace_who = 0;
660                         break;
661                 default:
662                         DEBUG(10, ("Got invalid ace_type: %d\n", ace->a_type));
663                         errno = EINVAL;
664                         SAFE_FREE(result);
665                         return NULL;
666                 }
667
668                 g_ace->ace_perm |= (ace->a_perm & SMB_ACL_READ) ?
669                         ACL_PERM_READ : 0;
670                 g_ace->ace_perm |= (ace->a_perm & SMB_ACL_WRITE) ?
671                         ACL_PERM_WRITE : 0;
672                 g_ace->ace_perm |= (ace->a_perm & SMB_ACL_EXECUTE) ?
673                         ACL_PERM_EXECUTE : 0;
674
675                 DEBUGADD(10, ("Converted to %d id %d perm %x\n",
676                               g_ace->ace_type, g_ace->ace_who, g_ace->ace_perm));
677         }
678
679         return result;
680 }
681
682 static int gpfsacl_sys_acl_set_file(vfs_handle_struct *handle,
683                                     const char *name,
684                                     SMB_ACL_TYPE_T type,
685                                     SMB_ACL_T theacl)
686 {
687         struct gpfs_acl *gpfs_acl;
688         int result;
689
690         gpfs_acl = smb2gpfs_acl(theacl, type);
691         if (gpfs_acl == NULL) {
692                 return -1;
693         }
694
695         result = smbd_gpfs_putacl((char *)name, GPFS_PUTACL_STRUCT | GPFS_ACL_SAMBA, gpfs_acl);
696
697         SAFE_FREE(gpfs_acl);
698         return result;
699 }
700
701 static int gpfsacl_sys_acl_set_fd(vfs_handle_struct *handle,
702                                   files_struct *fsp,
703                                   SMB_ACL_T theacl)
704 {
705         return gpfsacl_sys_acl_set_file(handle, fsp->fsp_name, SMB_ACL_TYPE_ACCESS, theacl);
706 }
707
708 static int gpfsacl_sys_acl_delete_def_file(vfs_handle_struct *handle,
709                                            const char *path)
710 {
711         errno = ENOTSUP;
712         return -1;
713 }
714
715 /*
716  * Assumed: mode bits are shiftable and standard
717  * Output: the new aceMask field for an smb nfs4 ace
718  */
719 static uint32 gpfsacl_mask_filter(uint32 aceType, uint32 aceMask, uint32 rwx)
720 {
721         const uint32 posix_nfs4map[3] = {
722                 SMB_ACE4_EXECUTE, /* execute */
723                 SMB_ACE4_WRITE_DATA | SMB_ACE4_APPEND_DATA, /* write; GPFS specific */
724                 SMB_ACE4_READ_DATA /* read */
725         };
726         int     i;
727         uint32_t        posix_mask = 0x01;
728         uint32_t        posix_bit;
729         uint32_t        nfs4_bits;
730
731         for(i=0; i<3; i++) {
732                 nfs4_bits = posix_nfs4map[i];
733                 posix_bit = rwx & posix_mask;
734
735                 if (aceType==SMB_ACE4_ACCESS_ALLOWED_ACE_TYPE) {
736                         if (posix_bit)
737                                 aceMask |= nfs4_bits;
738                         else
739                                 aceMask &= ~nfs4_bits;
740                 } else {
741                         /* add deny bits when suitable */
742                         if (!posix_bit)
743                                 aceMask |= nfs4_bits;
744                         else
745                                 aceMask &= ~nfs4_bits;
746                 } /* other ace types are unexpected */
747
748                 posix_mask <<= 1;
749         }
750
751         return aceMask;
752 }
753
754 static int gpfsacl_emu_chmod(const char *path, mode_t mode)
755 {
756         SMB4ACL_T *pacl = NULL;
757         int     result;
758         bool    haveAllowEntry[SMB_ACE4_WHO_EVERYONE + 1] = {False, False, False, False};
759         int     i;
760         files_struct    fake_fsp; /* TODO: rationalize parametrization */
761         SMB4ACE_T       *smbace;
762
763         DEBUG(10, ("gpfsacl_emu_chmod invoked for %s mode %o\n", path, mode));
764
765         result = gpfs_get_nfs4_acl(path, &pacl);
766         if (result)
767                 return result;
768
769         if (mode & ~(S_IRWXU | S_IRWXG | S_IRWXO)) {
770                 DEBUG(2, ("WARNING: cutting extra mode bits %o on %s\n", mode, path));
771         }
772
773         for (smbace=smb_first_ace4(pacl); smbace!=NULL; smbace = smb_next_ace4(smbace)) {
774                 SMB_ACE4PROP_T  *ace = smb_get_ace4(smbace);
775                 uint32_t        specid = ace->who.special_id;
776
777                 if (ace->flags&SMB_ACE4_ID_SPECIAL &&
778                     ace->aceType<=SMB_ACE4_ACCESS_DENIED_ACE_TYPE &&
779                     specid <= SMB_ACE4_WHO_EVERYONE) {
780
781                         uint32_t newMask;
782
783                         if (ace->aceType==SMB_ACE4_ACCESS_ALLOWED_ACE_TYPE)
784                                 haveAllowEntry[specid] = True;
785
786                         /* mode >> 6 for @owner, mode >> 3 for @group,
787                          * mode >> 0 for @everyone */
788                         newMask = gpfsacl_mask_filter(ace->aceType, ace->aceMask,
789                                                       mode >> ((SMB_ACE4_WHO_EVERYONE - specid) * 3));
790                         if (ace->aceMask!=newMask) {
791                                 DEBUG(10, ("ace changed for %s (%o -> %o) id=%d\n",
792                                            path, ace->aceMask, newMask, specid));
793                         }
794                         ace->aceMask = newMask;
795                 }
796         }
797
798         /* make sure we have at least ALLOW entries
799          * for all the 3 special ids (@EVERYONE, @OWNER, @GROUP)
800          * - if necessary
801          */
802         for(i = SMB_ACE4_WHO_OWNER; i<=SMB_ACE4_WHO_EVERYONE; i++) {
803                 SMB_ACE4PROP_T  ace;
804
805                 if (haveAllowEntry[i]==True)
806                         continue;
807
808                 ZERO_STRUCT(ace);
809                 ace.aceType = SMB_ACE4_ACCESS_ALLOWED_ACE_TYPE;
810                 ace.flags |= SMB_ACE4_ID_SPECIAL;
811                 ace.who.special_id = i;
812
813                 if (i==SMB_ACE4_WHO_GROUP) /* not sure it's necessary... */
814                         ace.aceFlags |= SMB_ACE4_IDENTIFIER_GROUP;
815
816                 ace.aceMask = gpfsacl_mask_filter(ace.aceType, ace.aceMask,
817                                                   mode >> ((SMB_ACE4_WHO_EVERYONE - i) * 3));
818
819                 /* don't add unnecessary aces */
820                 if (!ace.aceMask)
821                         continue;
822
823                 /* we add it to the END - as windows expects allow aces */
824                 smb_add_ace4(pacl, &ace);
825                 DEBUG(10, ("Added ALLOW ace for %s, mode=%o, id=%d, aceMask=%x\n",
826                            path, mode, i, ace.aceMask));
827         }
828
829         /* don't add complementary DENY ACEs here */
830         ZERO_STRUCT(fake_fsp);
831         fake_fsp.fsp_name = (char *)path; /* no file_new is needed here */
832
833         /* put the acl */
834         if (gpfsacl_process_smbacl(&fake_fsp, pacl) == False)
835                 return -1;
836         return 0; /* ok for [f]chmod */
837 }
838
839 static int vfs_gpfs_chmod(vfs_handle_struct *handle, const char *path, mode_t mode)
840 {
841                  SMB_STRUCT_STAT st;
842                  int rc;
843
844                  if (SMB_VFS_NEXT_STAT(handle, path, &st) != 0) {
845                          return -1;
846                  }
847
848                  /* avoid chmod() if possible, to preserve acls */
849                  if ((st.st_ex_mode & ~S_IFMT) == mode) {
850                          return 0;
851                  }
852
853                  rc = gpfsacl_emu_chmod(path, mode);
854                  if (rc == 1)
855                          return SMB_VFS_NEXT_CHMOD(handle, path, mode);
856                  return rc;
857 }
858
859 static int vfs_gpfs_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
860 {
861                  SMB_STRUCT_STAT st;
862                  int rc;
863
864                  if (SMB_VFS_NEXT_FSTAT(handle, fsp, &st) != 0) {
865                          return -1;
866                  }
867
868                  /* avoid chmod() if possible, to preserve acls */
869                  if ((st.st_ex_mode & ~S_IFMT) == mode) {
870                          return 0;
871                  }
872
873                  rc = gpfsacl_emu_chmod(fsp->fsp_name, mode);
874                  if (rc == 1)
875                          return SMB_VFS_NEXT_FCHMOD(handle, fsp, mode);
876                  return rc;
877 }
878
879 static int gpfs_set_xattr(struct vfs_handle_struct *handle,  const char *path,
880                            const char *name, const void *value, size_t size,  int flags){
881         const char *attrstr = value;
882         unsigned int dosmode=0;
883         struct gpfs_winattr attrs;
884         int ret = 0;
885
886         DEBUG(10, ("gpfs_set_xattr: %s \n",path));
887
888         /* Only handle DOS Attributes */
889         if (strcmp(name,SAMBA_XATTR_DOS_ATTRIB) != 0){
890                 DEBUG(1, ("gpfs_set_xattr:name is %s\n",name));
891                 return SMB_VFS_NEXT_SETXATTR(handle,path,name,value,size,flags);
892         }
893
894         if (size < 2 || attrstr[0] != '0' || attrstr[1] != 'x' ||
895                                 sscanf(attrstr, "%x", &dosmode) != 1) {
896                         DEBUG(1,("gpfs_set_xattr: Trying to set badly formed DOSATTRIB on file %s - %s\n", path, attrstr));
897                 return False;
898         }
899
900         attrs.winAttrs = 0;
901         /*Just map RD_ONLY, ARCHIVE, SYSTEM and HIDDEN. Ignore the others*/
902         if (dosmode & FILE_ATTRIBUTE_ARCHIVE){
903                 attrs.winAttrs |= GPFS_WINATTR_ARCHIVE;
904         }
905         if (dosmode & FILE_ATTRIBUTE_HIDDEN){
906                         attrs.winAttrs |= GPFS_WINATTR_HIDDEN;
907                 }
908         if (dosmode & FILE_ATTRIBUTE_SYSTEM){
909                         attrs.winAttrs |= GPFS_WINATTR_SYSTEM;
910                 }
911         if (dosmode & FILE_ATTRIBUTE_READONLY){
912                         attrs.winAttrs |= GPFS_WINATTR_READONLY;
913         }
914
915
916         ret = set_gpfs_winattrs(CONST_DISCARD(char *, path),
917                                 GPFS_WINATTR_SET_ATTRS, &attrs);
918         if ( ret == -1){
919                 DEBUG(1, ("gpfs_set_xattr:Set GPFS attributes failed %d\n",ret));
920                 return -1;
921         }
922
923         DEBUG(10, ("gpfs_set_xattr:Set attributes: 0x%x\n",attrs.winAttrs));
924         return 0;
925 }
926
927 static size_t gpfs_get_xattr(struct vfs_handle_struct *handle,  const char *path,
928                               const char *name, void *value, size_t size){
929         char *attrstr = value;
930         unsigned int dosmode = 0;
931         struct gpfs_winattr attrs;
932         int ret = 0;
933
934         DEBUG(10, ("gpfs_get_xattr: %s \n",path));
935
936         /* Only handle DOS Attributes */
937         if (strcmp(name,SAMBA_XATTR_DOS_ATTRIB) != 0){
938                 DEBUG(1, ("gpfs_get_xattr:name is %s\n",name));
939                 return SMB_VFS_NEXT_GETXATTR(handle,path,name,value,size);
940         }
941
942         ret = get_gpfs_winattrs(CONST_DISCARD(char *, path), &attrs);
943         if ( ret == -1){
944                 DEBUG(1, ("gpfs_get_xattr: Get GPFS attributes failed: %d\n",ret));
945                 return -1;
946         }
947
948         DEBUG(10, ("gpfs_get_xattr:Got attributes: 0x%x\n",attrs.winAttrs));
949
950         /*Just map RD_ONLY, ARCHIVE, SYSTEM and HIDDEN. Ignore the others*/
951         if (attrs.winAttrs & GPFS_WINATTR_ARCHIVE){
952                 dosmode |= FILE_ATTRIBUTE_ARCHIVE;
953         }
954         if (attrs.winAttrs & GPFS_WINATTR_HIDDEN){
955                 dosmode |= FILE_ATTRIBUTE_HIDDEN;
956         }
957         if (attrs.winAttrs & GPFS_WINATTR_SYSTEM){
958                 dosmode |= FILE_ATTRIBUTE_SYSTEM;
959         }
960         if (attrs.winAttrs & GPFS_WINATTR_READONLY){
961                 dosmode |= FILE_ATTRIBUTE_READONLY;
962         }
963
964         snprintf(attrstr, size, "0x%x", dosmode & SAMBA_ATTRIBUTES_MASK);
965         DEBUG(10, ("gpfs_get_xattr: returning %s\n",attrstr));
966         return size;
967 }
968
969 static int vfs_gpfs_stat(struct vfs_handle_struct *handle, const char *fname,
970                          SMB_STRUCT_STAT *sbuf)
971 {
972         struct gpfs_winattr attrs;
973         int ret;
974
975         ret = SMB_VFS_NEXT_STAT(handle, fname, sbuf);
976         if (ret == -1) {
977                 return -1;
978         }
979         ret = get_gpfs_winattrs(CONST_DISCARD(char *, fname), &attrs);
980         if (ret == 0) {
981                 sbuf->st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
982                 sbuf->st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
983         }
984         return 0;
985 }
986
987 static int vfs_gpfs_fstat(struct vfs_handle_struct *handle,
988                           struct files_struct *fsp, SMB_STRUCT_STAT *sbuf)
989 {
990         struct gpfs_winattr attrs;
991         int ret;
992
993         ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
994         if (ret == -1) {
995                 return -1;
996         }
997         if ((fsp->fh == NULL) || (fsp->fh->fd == -1)) {
998                 return 0;
999         }
1000         ret = smbd_fget_gpfs_winattrs(fsp->fh->fd, &attrs);
1001         if (ret == 0) {
1002                 sbuf->st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
1003                 sbuf->st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
1004         }
1005         return 0;
1006 }
1007
1008 static int vfs_gpfs_lstat(struct vfs_handle_struct *handle, const char *path,
1009                           SMB_STRUCT_STAT *sbuf)
1010 {
1011         struct gpfs_winattr attrs;
1012         int ret;
1013
1014         ret = SMB_VFS_NEXT_LSTAT(handle, path, sbuf);
1015         if (ret == -1) {
1016                 return -1;
1017         }
1018         ret = get_gpfs_winattrs(CONST_DISCARD(char *, path), &attrs);
1019         if (ret == 0) {
1020                 sbuf->st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
1021                 sbuf->st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
1022         }
1023         return 0;
1024 }
1025
1026 /* VFS operations structure */
1027
1028 static vfs_op_tuple gpfs_op_tuples[] = {
1029
1030         { SMB_VFS_OP(vfs_gpfs_kernel_flock), 
1031           SMB_VFS_OP_KERNEL_FLOCK,
1032           SMB_VFS_LAYER_OPAQUE },
1033
1034         { SMB_VFS_OP(vfs_gpfs_setlease), 
1035           SMB_VFS_OP_LINUX_SETLEASE,
1036           SMB_VFS_LAYER_OPAQUE },
1037
1038         { SMB_VFS_OP(vfs_gpfs_get_real_filename),
1039           SMB_VFS_OP_GET_REAL_FILENAME,
1040           SMB_VFS_LAYER_OPAQUE },
1041
1042         { SMB_VFS_OP(gpfsacl_fget_nt_acl), 
1043           SMB_VFS_OP_FGET_NT_ACL,
1044           SMB_VFS_LAYER_TRANSPARENT },
1045
1046         { SMB_VFS_OP(gpfsacl_get_nt_acl), 
1047           SMB_VFS_OP_GET_NT_ACL,
1048           SMB_VFS_LAYER_TRANSPARENT },
1049
1050         { SMB_VFS_OP(gpfsacl_fset_nt_acl), 
1051           SMB_VFS_OP_FSET_NT_ACL,
1052           SMB_VFS_LAYER_TRANSPARENT },
1053
1054         { SMB_VFS_OP(gpfsacl_sys_acl_get_file), 
1055           SMB_VFS_OP_SYS_ACL_GET_FILE,
1056           SMB_VFS_LAYER_TRANSPARENT },
1057
1058         { SMB_VFS_OP(gpfsacl_sys_acl_get_fd), 
1059           SMB_VFS_OP_SYS_ACL_GET_FD,
1060           SMB_VFS_LAYER_TRANSPARENT },
1061
1062         { SMB_VFS_OP(gpfsacl_sys_acl_set_file), 
1063           SMB_VFS_OP_SYS_ACL_SET_FILE,
1064           SMB_VFS_LAYER_TRANSPARENT },
1065
1066         { SMB_VFS_OP(gpfsacl_sys_acl_set_fd), 
1067           SMB_VFS_OP_SYS_ACL_SET_FD,
1068           SMB_VFS_LAYER_TRANSPARENT },
1069
1070         { SMB_VFS_OP(gpfsacl_sys_acl_delete_def_file),
1071           SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
1072           SMB_VFS_LAYER_TRANSPARENT },
1073
1074         { SMB_VFS_OP(vfs_gpfs_chmod), 
1075           SMB_VFS_OP_CHMOD,
1076           SMB_VFS_LAYER_TRANSPARENT },
1077
1078         { SMB_VFS_OP(vfs_gpfs_fchmod), 
1079           SMB_VFS_OP_FCHMOD,
1080           SMB_VFS_LAYER_TRANSPARENT },
1081
1082         { SMB_VFS_OP(vfs_gpfs_close),
1083           SMB_VFS_OP_CLOSE,
1084           SMB_VFS_LAYER_TRANSPARENT },
1085
1086         { SMB_VFS_OP(gpfs_set_xattr),
1087           SMB_VFS_OP_SETXATTR,
1088           SMB_VFS_LAYER_TRANSPARENT },
1089
1090         { SMB_VFS_OP(gpfs_get_xattr),
1091           SMB_VFS_OP_GETXATTR,
1092           SMB_VFS_LAYER_TRANSPARENT },
1093
1094         { SMB_VFS_OP(vfs_gpfs_stat),
1095           SMB_VFS_OP_STAT,
1096           SMB_VFS_LAYER_TRANSPARENT },
1097
1098         { SMB_VFS_OP(vfs_gpfs_fstat),
1099           SMB_VFS_OP_FSTAT,
1100           SMB_VFS_LAYER_TRANSPARENT },
1101
1102         { SMB_VFS_OP(vfs_gpfs_lstat),
1103           SMB_VFS_OP_LSTAT,
1104           SMB_VFS_LAYER_TRANSPARENT },
1105
1106         { SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP }
1107
1108 };
1109
1110
1111 NTSTATUS vfs_gpfs_init(void);
1112 NTSTATUS vfs_gpfs_init(void)
1113 {
1114         init_gpfs();
1115
1116         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "gpfs",
1117                                 gpfs_op_tuples);
1118 }