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 #include "smbd/smbd.h"
  26 #include "librpc/gen_ndr/ndr_xattr.h"
  27 #include "include/smbprofile.h"
  28
  29 #undef DBGC_CLASS
  30 #define DBGC_CLASS DBGC_VFS
  31
  32 #include <gpfs_gpl.h>
  33 #include "nfs4_acls.h"
  34 #include "vfs_gpfs.h"
  35 #include "system/filesys.h"
  36
  37 struct gpfs_config_data {
  38         bool sharemodes;
  39         bool leases;
  40         bool hsm;
  41         bool syncio;
  42         bool winattr;
  43         bool ftruncate;
  44 };
  45
  46
  47 static int vfs_gpfs_kernel_flock(vfs_handle_struct *handle, files_struct *fsp,
  48                                  uint32 share_mode, uint32 access_mask)
  49 {
  50
  51         struct gpfs_config_data *config;
  52
  53         SMB_VFS_HANDLE_GET_DATA(handle, config,
  54                                 struct gpfs_config_data,
  55                                 return -1);
  56
  57         START_PROFILE(syscall_kernel_flock);
  58
  59         kernel_flock(fsp->fh->fd, share_mode, access_mask);
  60
  61         if (config->sharemodes
  62                 && !set_gpfs_sharemode(fsp, access_mask, fsp->share_access)) {
  63                 return -1;
  64         }
  65
  66         END_PROFILE(syscall_kernel_flock);
  67
  68         return 0;
  69 }
  70
  71 static int vfs_gpfs_close(vfs_handle_struct *handle, files_struct *fsp)
  72 {
  73
  74         struct gpfs_config_data *config;
  75
  76         SMB_VFS_HANDLE_GET_DATA(handle, config,
  77                                 struct gpfs_config_data,
  78                                 return -1);
  79
  80         if (config->sharemodes && (fsp->fh != NULL) && (fsp->fh->fd != -1)) {
  81                 set_gpfs_sharemode(fsp, 0, 0);
  82         }
  83
  84         return SMB_VFS_NEXT_CLOSE(handle, fsp);
  85 }
  86
  87 static int vfs_gpfs_setlease(vfs_handle_struct *handle, files_struct *fsp,
  88                              int leasetype)
  89 {
  90         struct gpfs_config_data *config;
  91         int ret=0;
  92
  93         SMB_VFS_HANDLE_GET_DATA(handle, config,
  94                                 struct gpfs_config_data,
  95                                 return -1);
  96
  97         START_PROFILE(syscall_linux_setlease);
  98
  99         if (linux_set_lease_sighandler(fsp->fh->fd) == -1)
 100                 return -1;
 101
 102         if (config->leases) {
 103                 ret = set_gpfs_lease(fsp->fh->fd,leasetype);
 104         }
 105
 106         if (ret < 0) {
 107                 /* This must have come from GPFS not being available */
 108                 /* or some other error, hence call the default */
 109                 ret = linux_setlease(fsp->fh->fd, leasetype);
 110         }
 111
 112         END_PROFILE(syscall_linux_setlease);
 113
 114         return ret;
 115 }
 116
 117 static int vfs_gpfs_get_real_filename(struct vfs_handle_struct *handle,
 118                                       const char *path,
 119                                       const char *name,
 120                                       TALLOC_CTX *mem_ctx,
 121                                       char **found_name)
 122 {
 123         int result;
 124         char *full_path;
 125         char real_pathname[PATH_MAX+1];
 126         int buflen;
 127         bool mangled;
 128
 129         mangled = mangle_is_mangled(name, handle->conn->params);
 130         if (mangled) {
 131                 return SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name,
 132                                                       mem_ctx, found_name);
 133         }
 134
 135         full_path = talloc_asprintf(talloc_tos(), "%s/%s", path, name);
 136         if (full_path == NULL) {
 137                 errno = ENOMEM;
 138                 return -1;
 139         }
 140
 141         buflen = sizeof(real_pathname) - 1;
 142
 143         result = smbd_gpfs_get_realfilename_path(full_path, real_pathname,
 144                                                  &buflen);
 145
 146         TALLOC_FREE(full_path);
 147
 148         if ((result == -1) && (errno == ENOSYS)) {
 149                 return SMB_VFS_NEXT_GET_REAL_FILENAME(
 150                         handle, path, name, mem_ctx, found_name);
 151         }
 152
 153         if (result == -1) {
 154                 DEBUG(10, ("smbd_gpfs_get_realfilename_path returned %s\n",
 155                            strerror(errno)));
 156                 return -1;
 157         }
 158
 159         /*
 160          * GPFS does not necessarily null-terminate the returned path
 161          * but instead returns the buffer length in buflen.
 162          */
 163
 164         if (buflen < sizeof(real_pathname)) {
 165                 real_pathname[buflen] = '\0';
 166         } else {
 167                 real_pathname[sizeof(real_pathname)-1] = '\0';
 168         }
 169
 170         DEBUG(10, ("smbd_gpfs_get_realfilename_path: %s/%s -> %s\n",
 171                    path, name, real_pathname));
 172
 173         name = strrchr_m(real_pathname, '/');
 174         if (name == NULL) {
 175                 errno = ENOENT;
 176                 return -1;
 177         }
 178
 179         *found_name = talloc_strdup(mem_ctx, name+1);
 180         if (*found_name == NULL) {
 181                 errno = ENOMEM;
 182                 return -1;
 183         }
 184
 185         return 0;
 186 }
 187
 188 static void gpfs_dumpacl(int level, struct gpfs_acl *gacl)
 189 {
 190         gpfs_aclCount_t i;
 191         if (gacl==NULL)
 192         {
 193                 DEBUG(0, ("gpfs acl is NULL\n"));
 194                 return;
 195         }
 196
 197         DEBUG(level, ("gpfs acl: nace: %d, type:%d, version:%d, level:%d, len:%d\n",
 198                 gacl->acl_nace, gacl->acl_type, gacl->acl_version, gacl->acl_level, gacl->acl_len));
 199         for(i=0; i<gacl->acl_nace; i++)
 200         {
 201                 struct gpfs_ace_v4 *gace = gacl->ace_v4 + i;
 202                 DEBUG(level, ("\tace[%d]: type:%d, flags:0x%x, mask:0x%x, iflags:0x%x, who:%u\n",
 203                         i, gace->aceType, gace->aceFlags, gace->aceMask,
 204                         gace->aceIFlags, gace->aceWho));
 205         }
 206 }
 207
 208 static struct gpfs_acl *gpfs_getacl_alloc(const char *fname, gpfs_aclType_t type)
 209 {
 210         struct gpfs_acl *acl;
 211         size_t len = 200;
 212         int ret;
 213         TALLOC_CTX *mem_ctx = talloc_tos();
 214
 215         acl = (struct gpfs_acl *)TALLOC_SIZE(mem_ctx, len);
 216         if (acl == NULL) {
 217                 errno = ENOMEM;
 218                 return NULL;
 219         }
 220
 221         acl->acl_len = len;
 222         acl->acl_level = 0;
 223         acl->acl_version = 0;
 224         acl->acl_type = type;
 225
 226         ret = smbd_gpfs_getacl((char *)fname, GPFS_GETACL_STRUCT | GPFS_ACL_SAMBA, acl);
 227         if ((ret != 0) && (errno == ENOSPC)) {
 228                 struct gpfs_acl *new_acl = (struct gpfs_acl *)TALLOC_SIZE(
 229                         mem_ctx, acl->acl_len + sizeof(struct gpfs_acl));
 230                 if (new_acl == NULL) {
 231                         errno = ENOMEM;
 232                         return NULL;
 233                 }
 234
 235                 new_acl->acl_len = acl->acl_len;
 236                 new_acl->acl_level = acl->acl_level;
 237                 new_acl->acl_version = acl->acl_version;
 238                 new_acl->acl_type = acl->acl_type;
 239                 acl = new_acl;
 240
 241                 ret = smbd_gpfs_getacl((char *)fname, GPFS_GETACL_STRUCT | GPFS_ACL_SAMBA, acl);
 242         }
 243         if (ret != 0)
 244         {
 245                 DEBUG(8, ("smbd_gpfs_getacl failed with %s\n",strerror(errno)));
 246                 return NULL;
 247         }
 248
 249         return acl;
 250 }
 251
 252 /* Tries to get nfs4 acls and returns SMB ACL allocated.
 253  * On failure returns 1 if it got non-NFSv4 ACL to prompt
 254  * retry with POSIX ACL checks.
 255  * On failure returns -1 if there is system (GPFS) error, check errno.
 256  * Returns 0 on success
 257  */
 258 static int gpfs_get_nfs4_acl(const char *fname, SMB4ACL_T **ppacl)
 259 {
 260         gpfs_aclCount_t i;
 261         struct gpfs_acl *gacl = NULL;
 262         DEBUG(10, ("gpfs_get_nfs4_acl invoked for %s\n", fname));
 263
 264         /* First get the real acl length */
 265         gacl = gpfs_getacl_alloc(fname, 0);
 266         if (gacl == NULL) {
 267                 DEBUG(9, ("gpfs_getacl failed for %s with %s\n",
 268                            fname, strerror(errno)));
 269                 return -1;
 270         }
 271
 272         if (gacl->acl_type != GPFS_ACL_TYPE_NFS4) {
 273                 DEBUG(10, ("Got non-nfsv4 acl\n"));
 274                 /* Retry with POSIX ACLs check */
 275                 return 1;
 276         }
 277
 278         *ppacl = smb_create_smb4acl();
 279
 280         DEBUG(10, ("len: %d, level: %d, version: %d, nace: %d\n",
 281                    gacl->acl_len, gacl->acl_level, gacl->acl_version,
 282                    gacl->acl_nace));
 283
 284         for (i=0; i<gacl->acl_nace; i++) {
 285                 struct gpfs_ace_v4 *gace = &gacl->ace_v4[i];
 286                 SMB_ACE4PROP_T smbace;
 287                 DEBUG(10, ("type: %d, iflags: %x, flags: %x, mask: %x, "
 288                            "who: %d\n", gace->aceType, gace->aceIFlags,
 289                            gace->aceFlags, gace->aceMask, gace->aceWho));
 290
 291                 ZERO_STRUCT(smbace);
 292                 if (gace->aceIFlags & ACE4_IFLAG_SPECIAL_ID) {
 293                         smbace.flags |= SMB_ACE4_ID_SPECIAL;
 294                         switch (gace->aceWho) {
 295                         case ACE4_SPECIAL_OWNER:
 296                                 smbace.who.special_id = SMB_ACE4_WHO_OWNER;
 297                                 break;
 298                         case ACE4_SPECIAL_GROUP:
 299                                 smbace.who.special_id = SMB_ACE4_WHO_GROUP;
 300                                 break;
 301                         case ACE4_SPECIAL_EVERYONE:
 302                                 smbace.who.special_id = SMB_ACE4_WHO_EVERYONE;
 303                                 break;
 304                         default:
 305                                 DEBUG(8, ("invalid special gpfs id %d "
 306                                           "ignored\n", gace->aceWho));
 307                                 continue; /* don't add it */
 308                         }
 309                 } else {
 310                         if (gace->aceFlags & ACE4_FLAG_GROUP_ID)
 311                                 smbace.who.gid = gace->aceWho;
 312                         else
 313                                 smbace.who.uid = gace->aceWho;
 314                 }
 315
 316                 /* remove redundent deny entries */
 317                 if (i > 0 && gace->aceType == SMB_ACE4_ACCESS_DENIED_ACE_TYPE) {
 318                         struct gpfs_ace_v4 *prev = &gacl->ace_v4[i-1];
 319                         if (prev->aceType == SMB_ACE4_ACCESS_ALLOWED_ACE_TYPE &&
 320                             prev->aceFlags == gace->aceFlags &&
 321                             prev->aceIFlags == gace->aceIFlags &&
 322                             (gace->aceMask & prev->aceMask) == 0 &&
 323                             gace->aceWho == prev->aceWho) {
 324                                 /* its redundent - skip it */
 325                                 continue;
 326                         }
 327                 }
 328
 329                 smbace.aceType = gace->aceType;
 330                 smbace.aceFlags = gace->aceFlags;
 331                 smbace.aceMask = gace->aceMask;
 332                 smb_add_ace4(*ppacl, &smbace);
 333         }
 334
 335         return 0;
 336 }
 337
 338 static NTSTATUS gpfsacl_fget_nt_acl(vfs_handle_struct *handle,
 339         files_struct *fsp, uint32 security_info,
 340         struct security_descriptor **ppdesc)
 341 {
 342         SMB4ACL_T *pacl = NULL;
 343         int     result;
 344
 345         *ppdesc = NULL;
 346         result = gpfs_get_nfs4_acl(fsp->fsp_name->base_name, &pacl);
 347
 348         if (result == 0)
 349                 return smb_fget_nt_acl_nfs4(fsp, security_info, ppdesc, pacl);
 350
 351         if (result > 0) {
 352                 DEBUG(10, ("retrying with posix acl...\n"));
 353                 return posix_fget_nt_acl(fsp, security_info, ppdesc);
 354         }
 355
 356         /* GPFS ACL was not read, something wrong happened, error code is set in errno */
 357         return map_nt_error_from_unix(errno);
 358 }
 359
 360 static NTSTATUS gpfsacl_get_nt_acl(vfs_handle_struct *handle,
 361         const char *name,
 362         uint32 security_info, struct security_descriptor **ppdesc)
 363 {
 364         SMB4ACL_T *pacl = NULL;
 365         int     result;
 366
 367         *ppdesc = NULL;
 368         result = gpfs_get_nfs4_acl(name, &pacl);
 369
 370         if (result == 0)
 371                 return smb_get_nt_acl_nfs4(handle->conn, name, security_info, ppdesc, pacl);
 372
 373         if (result > 0) {
 374                 DEBUG(10, ("retrying with posix acl...\n"));
 375                 return posix_get_nt_acl(handle->conn, name, security_info, ppdesc);
 376         }
 377
 378         /* GPFS ACL was not read, something wrong happened, error code is set in errno */
 379         return map_nt_error_from_unix(errno);
 380 }
 381
 382 static bool gpfsacl_process_smbacl(files_struct *fsp, SMB4ACL_T *smbacl)
 383 {
 384         int ret;
 385         gpfs_aclLen_t gacl_len;
 386         SMB4ACE_T       *smbace;
 387         struct gpfs_acl *gacl;
 388         TALLOC_CTX *mem_ctx  = talloc_tos();
 389
 390         gacl_len = sizeof(struct gpfs_acl) +
 391                 (smb_get_naces(smbacl)-1)*sizeof(gpfs_ace_v4_t);
 392
 393         gacl = (struct gpfs_acl *)TALLOC_SIZE(mem_ctx, gacl_len);
 394         if (gacl == NULL) {
 395                 DEBUG(0, ("talloc failed\n"));
 396                 errno = ENOMEM;
 397                 return False;
 398         }
 399
 400         gacl->acl_len = gacl_len;
 401         gacl->acl_level = 0;
 402         gacl->acl_version = GPFS_ACL_VERSION_NFS4;
 403         gacl->acl_type = GPFS_ACL_TYPE_NFS4;
 404         gacl->acl_nace = 0; /* change later... */
 405
 406         for (smbace=smb_first_ace4(smbacl); smbace!=NULL; smbace = smb_next_ace4(smbace)) {
 407                 struct gpfs_ace_v4 *gace = &gacl->ace_v4[gacl->acl_nace];
 408                 SMB_ACE4PROP_T  *aceprop = smb_get_ace4(smbace);
 409
 410                 gace->aceType = aceprop->aceType;
 411                 gace->aceFlags = aceprop->aceFlags;
 412                 gace->aceMask = aceprop->aceMask;
 413
 414                 /*
 415                  * GPFS can't distinguish between WRITE and APPEND on
 416                  * files, so one being set without the other is an
 417                  * error. Sorry for the many ()'s :-)
 418                  */
 419
 420                 if (!fsp->is_directory
 421                     &&
 422                     ((((gace->aceMask & ACE4_MASK_WRITE) == 0)
 423                       && ((gace->aceMask & ACE4_MASK_APPEND) != 0))
 424                      ||
 425                      (((gace->aceMask & ACE4_MASK_WRITE) != 0)
 426                       && ((gace->aceMask & ACE4_MASK_APPEND) == 0)))
 427                     &&
 428                     lp_parm_bool(fsp->conn->params->service, "gpfs",
 429                                  "merge_writeappend", True)) {
 430                         DEBUG(2, ("vfs_gpfs.c: file [%s]: ACE contains "
 431                                   "WRITE^APPEND, setting WRITE|APPEND\n",
 432                                   fsp_str_dbg(fsp)));
 433                         gace->aceMask |= ACE4_MASK_WRITE|ACE4_MASK_APPEND;
 434                 }
 435
 436                 gace->aceIFlags = (aceprop->flags&SMB_ACE4_ID_SPECIAL) ? ACE4_IFLAG_SPECIAL_ID : 0;
 437
 438                 if (aceprop->flags&SMB_ACE4_ID_SPECIAL)
 439                 {
 440                         switch(aceprop->who.special_id)
 441                         {
 442                         case SMB_ACE4_WHO_EVERYONE:
 443                                 gace->aceWho = ACE4_SPECIAL_EVERYONE;
 444                                 break;
 445                         case SMB_ACE4_WHO_OWNER:
 446                                 gace->aceWho = ACE4_SPECIAL_OWNER;
 447                                 break;
 448                         case SMB_ACE4_WHO_GROUP:
 449                                 gace->aceWho = ACE4_SPECIAL_GROUP;
 450                                 break;
 451                         default:
 452                                 DEBUG(8, ("unsupported special_id %d\n", aceprop->who.special_id));
 453                                 continue; /* don't add it !!! */
 454                         }
 455                 } else {
 456                         /* just only for the type safety... */
 457                         if (aceprop->aceFlags&SMB_ACE4_IDENTIFIER_GROUP)
 458                                 gace->aceWho = aceprop->who.gid;
 459                         else
 460                                 gace->aceWho = aceprop->who.uid;
 461                 }
 462
 463                 gacl->acl_nace++;
 464         }
 465
 466         ret = smbd_gpfs_putacl(fsp->fsp_name->base_name,
 467                                GPFS_PUTACL_STRUCT | GPFS_ACL_SAMBA, gacl);
 468         if (ret != 0) {
 469                 DEBUG(8, ("gpfs_putacl failed with %s\n", strerror(errno)));
 470                 gpfs_dumpacl(8, gacl);
 471                 return False;
 472         }
 473
 474         DEBUG(10, ("gpfs_putacl succeeded\n"));
 475         return True;
 476 }
 477
 478 static NTSTATUS gpfsacl_set_nt_acl_internal(files_struct *fsp, uint32 security_info_sent, const struct security_descriptor *psd)
 479 {
 480         struct gpfs_acl *acl;
 481         NTSTATUS result = NT_STATUS_ACCESS_DENIED;
 482
 483         acl = gpfs_getacl_alloc(fsp->fsp_name->base_name, 0);
 484         if (acl == NULL)
 485                 return result;
 486
 487         if (acl->acl_version&GPFS_ACL_VERSION_NFS4)
 488         {
 489                 if (lp_parm_bool(fsp->conn->params->service, "gpfs",
 490                                  "refuse_dacl_protected", false)
 491                     && (psd->type&SEC_DESC_DACL_PROTECTED)) {
 492                         DEBUG(2, ("Rejecting unsupported ACL with DACL_PROTECTED bit set\n"));
 493                         return NT_STATUS_NOT_SUPPORTED;
 494                 }
 495
 496                 result = smb_set_nt_acl_nfs4(
 497                         fsp, security_info_sent, psd,
 498                         gpfsacl_process_smbacl);
 499         } else { /* assume POSIX ACL - by default... */
 500                 result = set_nt_acl(fsp, security_info_sent, psd);
 501         }
 502
 503         return result;
 504 }
 505
 506 static NTSTATUS gpfsacl_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const struct security_descriptor *psd)
 507 {
 508         return gpfsacl_set_nt_acl_internal(fsp, security_info_sent, psd);
 509 }
 510
 511 static SMB_ACL_T gpfs2smb_acl(const struct gpfs_acl *pacl)
 512 {
 513         SMB_ACL_T result;
 514         gpfs_aclCount_t i;
 515
 516         result = sys_acl_init(pacl->acl_nace);
 517         if (result == NULL) {
 518                 errno = ENOMEM;
 519                 return NULL;
 520         }
 521
 522         result->count = pacl->acl_nace;
 523
 524         for (i=0; i<pacl->acl_nace; i++) {
 525                 struct smb_acl_entry *ace = &result->acl[i];
 526                 const struct gpfs_ace_v1 *g_ace = &pacl->ace_v1[i];
 527
 528                 DEBUG(10, ("Converting type %d id %lu perm %x\n",
 529                            (int)g_ace->ace_type, (unsigned long)g_ace->ace_who,
 530                            (int)g_ace->ace_perm));
 531
 532                 switch (g_ace->ace_type) {
 533                 case GPFS_ACL_USER:
 534                         ace->a_type = SMB_ACL_USER;
 535                         ace->uid = (uid_t)g_ace->ace_who;
 536                         break;
 537                 case GPFS_ACL_USER_OBJ:
 538                         ace->a_type = SMB_ACL_USER_OBJ;
 539                         break;
 540                 case GPFS_ACL_GROUP:
 541                         ace->a_type = SMB_ACL_GROUP;
 542                         ace->gid = (gid_t)g_ace->ace_who;
 543                         break;
 544                 case GPFS_ACL_GROUP_OBJ:
 545                         ace->a_type = SMB_ACL_GROUP_OBJ;
 546                         break;
 547                 case GPFS_ACL_OTHER:
 548                         ace->a_type = SMB_ACL_OTHER;
 549                         break;
 550                 case GPFS_ACL_MASK:
 551                         ace->a_type = SMB_ACL_MASK;
 552                         break;
 553                 default:
 554                         DEBUG(10, ("Got invalid ace_type: %d\n",
 555                                    g_ace->ace_type));
 556                         errno = EINVAL;
 557                         SAFE_FREE(result);
 558                         return NULL;
 559                 }
 560
 561                 ace->a_perm = 0;
 562                 ace->a_perm |= (g_ace->ace_perm & ACL_PERM_READ) ?
 563                         SMB_ACL_READ : 0;
 564                 ace->a_perm |= (g_ace->ace_perm & ACL_PERM_WRITE) ?
 565                         SMB_ACL_WRITE : 0;
 566                 ace->a_perm |= (g_ace->ace_perm & ACL_PERM_EXECUTE) ?
 567                         SMB_ACL_EXECUTE : 0;
 568
 569                 DEBUGADD(10, ("Converted to %d perm %x\n",
 570                               ace->a_type, ace->a_perm));
 571         }
 572
 573         return result;
 574 }
 575
 576 static SMB_ACL_T gpfsacl_get_posix_acl(const char *path, gpfs_aclType_t type)
 577 {
 578         struct gpfs_acl *pacl;
 579         SMB_ACL_T result = NULL;
 580
 581         pacl = gpfs_getacl_alloc(path, type);
 582
 583         if (pacl == NULL) {
 584                 DEBUG(10, ("gpfs_getacl failed for %s with %s\n",
 585                            path, strerror(errno)));
 586                 if (errno == 0) {
 587                         errno = EINVAL;
 588                 }
 589                 goto done;
 590         }
 591
 592         if (pacl->acl_version != GPFS_ACL_VERSION_POSIX) {
 593                 DEBUG(10, ("Got acl version %d, expected %d\n",
 594                            pacl->acl_version, GPFS_ACL_VERSION_POSIX));
 595                 errno = EINVAL;
 596                 goto done;
 597         }
 598
 599         DEBUG(10, ("len: %d, level: %d, version: %d, nace: %d\n",
 600                    pacl->acl_len, pacl->acl_level, pacl->acl_version,
 601                    pacl->acl_nace));
 602
 603         result = gpfs2smb_acl(pacl);
 604         if (result == NULL) {
 605                 goto done;
 606         }
 607
 608  done:
 609
 610         if (errno != 0) {
 611                 SAFE_FREE(result);
 612         }
 613         return result;
 614 }
 615
 616 static SMB_ACL_T gpfsacl_sys_acl_get_file(vfs_handle_struct *handle,
 617                                           const char *path_p,
 618                                           SMB_ACL_TYPE_T type)
 619 {
 620         gpfs_aclType_t gpfs_type;
 621
 622         switch(type) {
 623         case SMB_ACL_TYPE_ACCESS:
 624                 gpfs_type = GPFS_ACL_TYPE_ACCESS;
 625                 break;
 626         case SMB_ACL_TYPE_DEFAULT:
 627                 gpfs_type = GPFS_ACL_TYPE_DEFAULT;
 628                 break;
 629         default:
 630                 DEBUG(0, ("Got invalid type: %d\n", type));
 631                 smb_panic("exiting");
 632         }
 633
 634         return gpfsacl_get_posix_acl(path_p, gpfs_type);
 635 }
 636
 637 static SMB_ACL_T gpfsacl_sys_acl_get_fd(vfs_handle_struct *handle,
 638                                         files_struct *fsp)
 639 {
 640         return gpfsacl_get_posix_acl(fsp->fsp_name->base_name,
 641                                      GPFS_ACL_TYPE_ACCESS);
 642 }
 643
 644 static struct gpfs_acl *smb2gpfs_acl(const SMB_ACL_T pacl,
 645                                      SMB_ACL_TYPE_T type)
 646 {
 647         gpfs_aclLen_t len;
 648         struct gpfs_acl *result;
 649         int i;
 650         union gpfs_ace_union
 651         {
 652                 gpfs_ace_v1_t  ace_v1[1]; /* when GPFS_ACL_VERSION_POSIX */
 653                 gpfs_ace_v4_t  ace_v4[1]; /* when GPFS_ACL_VERSION_NFS4  */
 654         };
 655
 656         DEBUG(10, ("smb2gpfs_acl: Got ACL with %d entries\n", pacl->count));
 657
 658         len = sizeof(struct gpfs_acl) - sizeof(union gpfs_ace_union) +
 659                 (pacl->count)*sizeof(gpfs_ace_v1_t);
 660
 661         result = (struct gpfs_acl *)SMB_MALLOC(len);
 662         if (result == NULL) {
 663                 errno = ENOMEM;
 664                 return result;
 665         }
 666
 667         result->acl_len = len;
 668         result->acl_level = 0;
 669         result->acl_version = GPFS_ACL_VERSION_POSIX;
 670         result->acl_type = (type == SMB_ACL_TYPE_DEFAULT) ?
 671                 GPFS_ACL_TYPE_DEFAULT : GPFS_ACL_TYPE_ACCESS;
 672         result->acl_nace = pacl->count;
 673
 674         for (i=0; i<pacl->count; i++) {
 675                 const struct smb_acl_entry *ace = &pacl->acl[i];
 676                 struct gpfs_ace_v1 *g_ace = &result->ace_v1[i];
 677
 678                 DEBUG(10, ("Converting type %d perm %x\n",
 679                            (int)ace->a_type, (int)ace->a_perm));
 680
 681                 g_ace->ace_perm = 0;
 682
 683                 switch(ace->a_type) {
 684                 case SMB_ACL_USER:
 685                         g_ace->ace_type = GPFS_ACL_USER;
 686                         g_ace->ace_who = (gpfs_uid_t)ace->uid;
 687                         break;
 688                 case SMB_ACL_USER_OBJ:
 689                         g_ace->ace_type = GPFS_ACL_USER_OBJ;
 690                         g_ace->ace_perm |= ACL_PERM_CONTROL;
 691                         g_ace->ace_who = 0;
 692                         break;
 693                 case SMB_ACL_GROUP:
 694                         g_ace->ace_type = GPFS_ACL_GROUP;
 695                         g_ace->ace_who = (gpfs_uid_t)ace->gid;
 696                         break;
 697                 case SMB_ACL_GROUP_OBJ:
 698                         g_ace->ace_type = GPFS_ACL_GROUP_OBJ;
 699                         g_ace->ace_who = 0;
 700                         break;
 701                 case SMB_ACL_MASK:
 702                         g_ace->ace_type = GPFS_ACL_MASK;
 703                         g_ace->ace_perm = 0x8f;
 704                         g_ace->ace_who = 0;
 705                         break;
 706                 case SMB_ACL_OTHER:
 707                         g_ace->ace_type = GPFS_ACL_OTHER;
 708                         g_ace->ace_who = 0;
 709                         break;
 710                 default:
 711                         DEBUG(10, ("Got invalid ace_type: %d\n", ace->a_type));
 712                         errno = EINVAL;
 713                         SAFE_FREE(result);
 714                         return NULL;
 715                 }
 716
 717                 g_ace->ace_perm |= (ace->a_perm & SMB_ACL_READ) ?
 718                         ACL_PERM_READ : 0;
 719                 g_ace->ace_perm |= (ace->a_perm & SMB_ACL_WRITE) ?
 720                         ACL_PERM_WRITE : 0;
 721                 g_ace->ace_perm |= (ace->a_perm & SMB_ACL_EXECUTE) ?
 722                         ACL_PERM_EXECUTE : 0;
 723
 724                 DEBUGADD(10, ("Converted to %d id %d perm %x\n",
 725                               g_ace->ace_type, g_ace->ace_who, g_ace->ace_perm));
 726         }
 727
 728         return result;
 729 }
 730
 731 static int gpfsacl_sys_acl_set_file(vfs_handle_struct *handle,
 732                                     const char *name,
 733                                     SMB_ACL_TYPE_T type,
 734                                     SMB_ACL_T theacl)
 735 {
 736         struct gpfs_acl *gpfs_acl;
 737         int result;
 738
 739         gpfs_acl = smb2gpfs_acl(theacl, type);
 740         if (gpfs_acl == NULL) {
 741                 return -1;
 742         }
 743
 744         result = smbd_gpfs_putacl((char *)name, GPFS_PUTACL_STRUCT | GPFS_ACL_SAMBA, gpfs_acl);
 745
 746         SAFE_FREE(gpfs_acl);
 747         return result;
 748 }
 749
 750 static int gpfsacl_sys_acl_set_fd(vfs_handle_struct *handle,
 751                                   files_struct *fsp,
 752                                   SMB_ACL_T theacl)
 753 {
 754         return gpfsacl_sys_acl_set_file(handle, fsp->fsp_name->base_name,
 755                                         SMB_ACL_TYPE_ACCESS, theacl);
 756 }
 757
 758 static int gpfsacl_sys_acl_delete_def_file(vfs_handle_struct *handle,
 759                                            const char *path)
 760 {
 761         errno = ENOTSUP;
 762         return -1;
 763 }
 764
 765 /*
 766  * Assumed: mode bits are shiftable and standard
 767  * Output: the new aceMask field for an smb nfs4 ace
 768  */
 769 static uint32 gpfsacl_mask_filter(uint32 aceType, uint32 aceMask, uint32 rwx)
 770 {
 771         const uint32 posix_nfs4map[3] = {
 772                 SMB_ACE4_EXECUTE, /* execute */
 773                 SMB_ACE4_WRITE_DATA | SMB_ACE4_APPEND_DATA, /* write; GPFS specific */
 774                 SMB_ACE4_READ_DATA /* read */
 775         };
 776         int     i;
 777         uint32_t        posix_mask = 0x01;
 778         uint32_t        posix_bit;
 779         uint32_t        nfs4_bits;
 780
 781         for(i=0; i<3; i++) {
 782                 nfs4_bits = posix_nfs4map[i];
 783                 posix_bit = rwx & posix_mask;
 784
 785                 if (aceType==SMB_ACE4_ACCESS_ALLOWED_ACE_TYPE) {
 786                         if (posix_bit)
 787                                 aceMask |= nfs4_bits;
 788                         else
 789                                 aceMask &= ~nfs4_bits;
 790                 } else {
 791                         /* add deny bits when suitable */
 792                         if (!posix_bit)
 793                                 aceMask |= nfs4_bits;
 794                         else
 795                                 aceMask &= ~nfs4_bits;
 796                 } /* other ace types are unexpected */
 797
 798                 posix_mask <<= 1;
 799         }
 800
 801         return aceMask;
 802 }
 803
 804 static int gpfsacl_emu_chmod(const char *path, mode_t mode)
 805 {
 806         SMB4ACL_T *pacl = NULL;
 807         int     result;
 808         bool    haveAllowEntry[SMB_ACE4_WHO_EVERYONE + 1] = {False, False, False, False};
 809         int     i;
 810         files_struct    fake_fsp; /* TODO: rationalize parametrization */
 811         SMB4ACE_T       *smbace;
 812         NTSTATUS status;
 813
 814         DEBUG(10, ("gpfsacl_emu_chmod invoked for %s mode %o\n", path, mode));
 815
 816         result = gpfs_get_nfs4_acl(path, &pacl);
 817         if (result)
 818                 return result;
 819
 820         if (mode & ~(S_IRWXU | S_IRWXG | S_IRWXO)) {
 821                 DEBUG(2, ("WARNING: cutting extra mode bits %o on %s\n", mode, path));
 822         }
 823
 824         for (smbace=smb_first_ace4(pacl); smbace!=NULL; smbace = smb_next_ace4(smbace)) {
 825                 SMB_ACE4PROP_T  *ace = smb_get_ace4(smbace);
 826                 uint32_t        specid = ace->who.special_id;
 827
 828                 if (ace->flags&SMB_ACE4_ID_SPECIAL &&
 829                     ace->aceType<=SMB_ACE4_ACCESS_DENIED_ACE_TYPE &&
 830                     specid <= SMB_ACE4_WHO_EVERYONE) {
 831
 832                         uint32_t newMask;
 833
 834                         if (ace->aceType==SMB_ACE4_ACCESS_ALLOWED_ACE_TYPE)
 835                                 haveAllowEntry[specid] = True;
 836
 837                         /* mode >> 6 for @owner, mode >> 3 for @group,
 838                          * mode >> 0 for @everyone */
 839                         newMask = gpfsacl_mask_filter(ace->aceType, ace->aceMask,
 840                                                       mode >> ((SMB_ACE4_WHO_EVERYONE - specid) * 3));
 841                         if (ace->aceMask!=newMask) {
 842                                 DEBUG(10, ("ace changed for %s (%o -> %o) id=%d\n",
 843                                            path, ace->aceMask, newMask, specid));
 844                         }
 845                         ace->aceMask = newMask;
 846                 }
 847         }
 848
 849         /* make sure we have at least ALLOW entries
 850          * for all the 3 special ids (@EVERYONE, @OWNER, @GROUP)
 851          * - if necessary
 852          */
 853         for(i = SMB_ACE4_WHO_OWNER; i<=SMB_ACE4_WHO_EVERYONE; i++) {
 854                 SMB_ACE4PROP_T  ace;
 855
 856                 if (haveAllowEntry[i]==True)
 857                         continue;
 858
 859                 ZERO_STRUCT(ace);
 860                 ace.aceType = SMB_ACE4_ACCESS_ALLOWED_ACE_TYPE;
 861                 ace.flags |= SMB_ACE4_ID_SPECIAL;
 862                 ace.who.special_id = i;
 863
 864                 if (i==SMB_ACE4_WHO_GROUP) /* not sure it's necessary... */
 865                         ace.aceFlags |= SMB_ACE4_IDENTIFIER_GROUP;
 866
 867                 ace.aceMask = gpfsacl_mask_filter(ace.aceType, ace.aceMask,
 868                                                   mode >> ((SMB_ACE4_WHO_EVERYONE - i) * 3));
 869
 870                 /* don't add unnecessary aces */
 871                 if (!ace.aceMask)
 872                         continue;
 873
 874                 /* we add it to the END - as windows expects allow aces */
 875                 smb_add_ace4(pacl, &ace);
 876                 DEBUG(10, ("Added ALLOW ace for %s, mode=%o, id=%d, aceMask=%x\n",
 877                            path, mode, i, ace.aceMask));
 878         }
 879
 880         /* don't add complementary DENY ACEs here */
 881         ZERO_STRUCT(fake_fsp);
 882         status = create_synthetic_smb_fname(talloc_tos(), path, NULL, NULL,
 883                                             &fake_fsp.fsp_name);
 884         if (!NT_STATUS_IS_OK(status)) {
 885                 errno = map_errno_from_nt_status(status);
 886                 return -1;
 887         }
 888         /* put the acl */
 889         if (gpfsacl_process_smbacl(&fake_fsp, pacl) == False) {
 890                 TALLOC_FREE(fake_fsp.fsp_name);
 891                 return -1;
 892         }
 893
 894         TALLOC_FREE(fake_fsp.fsp_name);
 895         return 0; /* ok for [f]chmod */
 896 }
 897
 898 static int vfs_gpfs_chmod(vfs_handle_struct *handle, const char *path, mode_t mode)
 899 {
 900         struct smb_filename *smb_fname_cpath;
 901         int rc;
 902         NTSTATUS status;
 903
 904         status = create_synthetic_smb_fname(
 905                 talloc_tos(), path, NULL, NULL, &smb_fname_cpath);
 906
 907         if (SMB_VFS_NEXT_STAT(handle, smb_fname_cpath) != 0) {
 908                 return -1;
 909         }
 910
 911         /* avoid chmod() if possible, to preserve acls */
 912         if ((smb_fname_cpath->st.st_ex_mode & ~S_IFMT) == mode) {
 913                 return 0;
 914         }
 915
 916         rc = gpfsacl_emu_chmod(path, mode);
 917         if (rc == 1)
 918                 return SMB_VFS_NEXT_CHMOD(handle, path, mode);
 919         return rc;
 920 }
 921
 922 static int vfs_gpfs_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
 923 {
 924                  SMB_STRUCT_STAT st;
 925                  int rc;
 926
 927                  if (SMB_VFS_NEXT_FSTAT(handle, fsp, &st) != 0) {
 928                          return -1;
 929                  }
 930
 931                  /* avoid chmod() if possible, to preserve acls */
 932                  if ((st.st_ex_mode & ~S_IFMT) == mode) {
 933                          return 0;
 934                  }
 935
 936                  rc = gpfsacl_emu_chmod(fsp->fsp_name->base_name, mode);
 937                  if (rc == 1)
 938                          return SMB_VFS_NEXT_FCHMOD(handle, fsp, mode);
 939                  return rc;
 940 }
 941
 942 static int gpfs_set_xattr(struct vfs_handle_struct *handle,  const char *path,
 943                            const char *name, const void *value, size_t size,  int flags){
 944         struct xattr_DOSATTRIB dosattrib;
 945         enum ndr_err_code ndr_err;
 946         DATA_BLOB blob;
 947         const char *attrstr = value;
 948         unsigned int dosmode=0;
 949         struct gpfs_winattr attrs;
 950         int ret = 0;
 951         struct gpfs_config_data *config;
 952
 953         SMB_VFS_HANDLE_GET_DATA(handle, config,
 954                                 struct gpfs_config_data,
 955                                 return -1);
 956
 957         if (!config->winattr) {
 958                 DEBUG(10, ("gpfs_set_xattr:name is %s -> next\n",name));
 959                 return SMB_VFS_NEXT_SETXATTR(handle,path,name,value,size,flags);
 960         }
 961
 962         DEBUG(10, ("gpfs_set_xattr: %s \n",path));
 963
 964         /* Only handle DOS Attributes */
 965         if (strcmp(name,SAMBA_XATTR_DOS_ATTRIB) != 0){
 966                 DEBUG(5, ("gpfs_set_xattr:name is %s\n",name));
 967                 return SMB_VFS_NEXT_SETXATTR(handle,path,name,value,size,flags);
 968         }
 969
 970         blob.data = (uint8_t *)attrstr;
 971         blob.length = size;
 972
 973         ndr_err = ndr_pull_struct_blob(&blob, talloc_tos(), &dosattrib,
 974                         (ndr_pull_flags_fn_t)ndr_pull_xattr_DOSATTRIB);
 975
 976         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 977                 DEBUG(1, ("gpfs_set_xattr: bad ndr decode "
 978                           "from EA on file %s: Error = %s\n",
 979                           path, ndr_errstr(ndr_err)));
 980                 return false;
 981         }
 982
 983         if (dosattrib.version != 3) {
 984                 DEBUG(1, ("gpfs_set_xattr: expected dosattrib version 3, got "
 985                           "%d\n", (int)dosattrib.version));
 986                 return false;
 987         }
 988         if (!(dosattrib.info.info3.valid_flags & XATTR_DOSINFO_ATTRIB)) {
 989                 DEBUG(10, ("gpfs_set_xattr: XATTR_DOSINFO_ATTRIB not "
 990                            "valid, ignoring\n"));
 991                 return true;
 992         }
 993
 994         dosmode = dosattrib.info.info3.attrib;
 995
 996         attrs.winAttrs = 0;
 997         /*Just map RD_ONLY, ARCHIVE, SYSTEM HIDDEN and SPARSE. Ignore the others*/
 998         if (dosmode & FILE_ATTRIBUTE_ARCHIVE){
 999                 attrs.winAttrs |= GPFS_WINATTR_ARCHIVE;
1000         }
1001         if (dosmode & FILE_ATTRIBUTE_HIDDEN){
1002                         attrs.winAttrs |= GPFS_WINATTR_HIDDEN;
1003                 }
1004         if (dosmode & FILE_ATTRIBUTE_SYSTEM){
1005                         attrs.winAttrs |= GPFS_WINATTR_SYSTEM;
1006                 }
1007         if (dosmode & FILE_ATTRIBUTE_READONLY){
1008                         attrs.winAttrs |= GPFS_WINATTR_READONLY;
1009         }
1010         if (dosmode & FILE_ATTRIBUTE_SPARSE) {
1011                 attrs.winAttrs |= GPFS_WINATTR_SPARSE_FILE;
1012         }
1013
1014
1015         ret = set_gpfs_winattrs(discard_const_p(char, path),
1016                                 GPFS_WINATTR_SET_ATTRS, &attrs);
1017         if ( ret == -1){
1018                 if (errno == ENOSYS) {
1019                         return SMB_VFS_NEXT_SETXATTR(handle, path, name, value,
1020                                                      size, flags);
1021                 }
1022
1023                 DEBUG(1, ("gpfs_set_xattr:Set GPFS attributes failed %d\n",ret));
1024                 return -1;
1025         }
1026
1027         DEBUG(10, ("gpfs_set_xattr:Set attributes: 0x%x\n",attrs.winAttrs));
1028         return 0;
1029 }
1030
1031 static ssize_t gpfs_get_xattr(struct vfs_handle_struct *handle,  const char *path,
1032                               const char *name, void *value, size_t size){
1033         char *attrstr = value;
1034         unsigned int dosmode = 0;
1035         struct gpfs_winattr attrs;
1036         int ret = 0;
1037         struct gpfs_config_data *config;
1038
1039         SMB_VFS_HANDLE_GET_DATA(handle, config,
1040                                 struct gpfs_config_data,
1041                                 return -1);
1042
1043         if (!config->winattr) {
1044                 DEBUG(10, ("gpfs_get_xattr:name is %s -> next\n",name));
1045                 return SMB_VFS_NEXT_GETXATTR(handle,path,name,value,size);
1046         }
1047
1048         DEBUG(10, ("gpfs_get_xattr: %s \n",path));
1049
1050         /* Only handle DOS Attributes */
1051         if (strcmp(name,SAMBA_XATTR_DOS_ATTRIB) != 0){
1052                 DEBUG(5, ("gpfs_get_xattr:name is %s\n",name));
1053                 return SMB_VFS_NEXT_GETXATTR(handle,path,name,value,size);
1054         }
1055
1056         ret = get_gpfs_winattrs(discard_const_p(char, path), &attrs);
1057         if ( ret == -1){
1058                 if (errno == ENOSYS) {
1059                         return SMB_VFS_NEXT_GETXATTR(handle, path, name, value,
1060                                                      size);
1061                 }
1062
1063                 DEBUG(1, ("gpfs_get_xattr: Get GPFS attributes failed: "
1064                           "%d (%s)\n", ret, strerror(errno)));
1065                 return -1;
1066         }
1067
1068         DEBUG(10, ("gpfs_get_xattr:Got attributes: 0x%x\n",attrs.winAttrs));
1069
1070         /*Just map RD_ONLY, ARCHIVE, SYSTEM, HIDDEN and SPARSE. Ignore the others*/
1071         if (attrs.winAttrs & GPFS_WINATTR_ARCHIVE){
1072                 dosmode |= FILE_ATTRIBUTE_ARCHIVE;
1073         }
1074         if (attrs.winAttrs & GPFS_WINATTR_HIDDEN){
1075                 dosmode |= FILE_ATTRIBUTE_HIDDEN;
1076         }
1077         if (attrs.winAttrs & GPFS_WINATTR_SYSTEM){
1078                 dosmode |= FILE_ATTRIBUTE_SYSTEM;
1079         }
1080         if (attrs.winAttrs & GPFS_WINATTR_READONLY){
1081                 dosmode |= FILE_ATTRIBUTE_READONLY;
1082         }
1083         if (attrs.winAttrs & GPFS_WINATTR_SPARSE_FILE) {
1084                 dosmode |= FILE_ATTRIBUTE_SPARSE;
1085         }
1086
1087         snprintf(attrstr, size, "0x%2.2x",
1088                  (unsigned int)(dosmode & SAMBA_ATTRIBUTES_MASK));
1089         DEBUG(10, ("gpfs_get_xattr: returning %s\n",attrstr));
1090         return 4;
1091 }
1092
1093 static int vfs_gpfs_stat(struct vfs_handle_struct *handle,
1094                          struct smb_filename *smb_fname)
1095 {
1096         struct gpfs_winattr attrs;
1097         char *fname = NULL;
1098         NTSTATUS status;
1099         int ret;
1100         struct gpfs_config_data *config;
1101
1102         SMB_VFS_HANDLE_GET_DATA(handle, config,
1103                                 struct gpfs_config_data,
1104                                 return -1);
1105
1106         ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
1107         if (ret == -1) {
1108                 return -1;
1109         }
1110
1111         if (!config->winattr) {
1112                 return 0;
1113         }
1114
1115         status = get_full_smb_filename(talloc_tos(), smb_fname, &fname);
1116         if (!NT_STATUS_IS_OK(status)) {
1117                 errno = map_errno_from_nt_status(status);
1118                 return -1;
1119         }
1120         ret = get_gpfs_winattrs(discard_const_p(char, fname), &attrs);
1121         TALLOC_FREE(fname);
1122         if (ret == 0) {
1123                 smb_fname->st.st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
1124                 smb_fname->st.st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
1125                 smb_fname->st.vfs_private = attrs.winAttrs;
1126         }
1127         return 0;
1128 }
1129
1130 static int vfs_gpfs_fstat(struct vfs_handle_struct *handle,
1131                           struct files_struct *fsp, SMB_STRUCT_STAT *sbuf)
1132 {
1133         struct gpfs_winattr attrs;
1134         int ret;
1135         struct gpfs_config_data *config;
1136
1137         SMB_VFS_HANDLE_GET_DATA(handle, config,
1138                                 struct gpfs_config_data,
1139                                 return -1);
1140
1141         ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
1142         if (ret == -1) {
1143                 return -1;
1144         }
1145         if ((fsp->fh == NULL) || (fsp->fh->fd == -1)) {
1146                 return 0;
1147         }
1148         if (!config->winattr) {
1149                 return 0;
1150         }
1151
1152         ret = smbd_fget_gpfs_winattrs(fsp->fh->fd, &attrs);
1153         if (ret == 0) {
1154                 sbuf->st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
1155                 sbuf->st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
1156         }
1157         return 0;
1158 }
1159
1160 static int vfs_gpfs_lstat(struct vfs_handle_struct *handle,
1161                           struct smb_filename *smb_fname)
1162 {
1163         struct gpfs_winattr attrs;
1164         char *path = NULL;
1165         NTSTATUS status;
1166         int ret;
1167         struct gpfs_config_data *config;
1168
1169         SMB_VFS_HANDLE_GET_DATA(handle, config,
1170                                 struct gpfs_config_data,
1171                                 return -1);
1172
1173         ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
1174         if (ret == -1) {
1175                 return -1;
1176         }
1177         if (!config->winattr) {
1178                 return 0;
1179         }
1180
1181         status = get_full_smb_filename(talloc_tos(), smb_fname, &path);
1182         if (!NT_STATUS_IS_OK(status)) {
1183                 errno = map_errno_from_nt_status(status);
1184                 return -1;
1185         }
1186         ret = get_gpfs_winattrs(discard_const_p(char, path), &attrs);
1187         TALLOC_FREE(path);
1188         if (ret == 0) {
1189                 smb_fname->st.st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
1190                 smb_fname->st.st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
1191                 smb_fname->st.vfs_private = attrs.winAttrs;
1192         }
1193         return 0;
1194 }
1195
1196 static int vfs_gpfs_ntimes(struct vfs_handle_struct *handle,
1197                         const struct smb_filename *smb_fname,
1198                         struct smb_file_time *ft)
1199 {
1200
1201         struct gpfs_winattr attrs;
1202         int ret;
1203         char *path = NULL;
1204         NTSTATUS status;
1205         struct gpfs_config_data *config;
1206
1207         SMB_VFS_HANDLE_GET_DATA(handle, config,
1208                                 struct gpfs_config_data,
1209                                 return -1);
1210
1211         ret = SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
1212         if(ret == -1){
1213                 DEBUG(1,("vfs_gpfs_ntimes: SMB_VFS_NEXT_NTIMES failed\n"));
1214                 return -1;
1215         }
1216
1217         if(null_timespec(ft->create_time)){
1218                 DEBUG(10,("vfs_gpfs_ntimes:Create Time is NULL\n"));
1219                 return 0;
1220         }
1221
1222         if (!config->winattr) {
1223                 return 0;
1224         }
1225
1226         status = get_full_smb_filename(talloc_tos(), smb_fname, &path);
1227         if (!NT_STATUS_IS_OK(status)) {
1228                 errno = map_errno_from_nt_status(status);
1229                 return -1;
1230         }
1231
1232         attrs.winAttrs = 0;
1233         attrs.creationTime.tv_sec = ft->create_time.tv_sec;
1234         attrs.creationTime.tv_nsec = ft->create_time.tv_nsec;
1235
1236         ret = set_gpfs_winattrs(discard_const_p(char, path),
1237                                 GPFS_WINATTR_SET_CREATION_TIME, &attrs);
1238         if(ret == -1 && errno != ENOSYS){
1239                 DEBUG(1,("vfs_gpfs_ntimes: set GPFS ntimes failed %d\n",ret));
1240                 return -1;
1241         }
1242         return 0;
1243
1244 }
1245
1246 static int vfs_gpfs_ftruncate(vfs_handle_struct *handle, files_struct *fsp,
1247                                 SMB_OFF_T len)
1248 {
1249         int result;
1250         struct gpfs_config_data *config;
1251
1252         SMB_VFS_HANDLE_GET_DATA(handle, config,
1253                                 struct gpfs_config_data,
1254                                 return -1);
1255
1256         if (!config->ftruncate) {
1257                 return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, len);
1258         }
1259
1260         result = smbd_gpfs_ftruncate(fsp->fh->fd, len);
1261         if ((result == -1) && (errno == ENOSYS)) {
1262                 return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, len);
1263         }
1264         return result;
1265 }
1266
1267 static bool vfs_gpfs_is_offline(struct vfs_handle_struct *handle,
1268                                 const struct smb_filename *fname,
1269                                 SMB_STRUCT_STAT *sbuf)
1270 {
1271         struct gpfs_winattr attrs;
1272         char *path = NULL;
1273         NTSTATUS status;
1274         struct gpfs_config_data *config;
1275
1276         SMB_VFS_HANDLE_GET_DATA(handle, config,
1277                                 struct gpfs_config_data,
1278                                 return -1);
1279
1280         if (!config->winattr) {
1281                 return SMB_VFS_NEXT_IS_OFFLINE(handle, fname, sbuf);
1282         }
1283
1284         status = get_full_smb_filename(talloc_tos(), fname, &path);
1285         if (!NT_STATUS_IS_OK(status)) {
1286                 errno = map_errno_from_nt_status(status);
1287                 return -1;
1288         }
1289
1290         if (VALID_STAT(*sbuf)) {
1291                 attrs.winAttrs = sbuf->vfs_private;
1292         } else {
1293                 int ret;
1294                 ret = get_gpfs_winattrs(path, &attrs);
1295
1296                 if (ret == -1) {
1297                         TALLOC_FREE(path);
1298                         return false;
1299                 }
1300         }
1301         if ((attrs.winAttrs & GPFS_WINATTR_OFFLINE) != 0) {
1302                 DEBUG(10, ("%s is offline\n", path));
1303                 TALLOC_FREE(path);
1304                 return true;
1305         }
1306         DEBUG(10, ("%s is online\n", path));
1307         TALLOC_FREE(path);
1308         return SMB_VFS_NEXT_IS_OFFLINE(handle, fname, sbuf);
1309 }
1310
1311 static bool vfs_gpfs_aio_force(struct vfs_handle_struct *handle,
1312                                struct files_struct *fsp)
1313 {
1314         return vfs_gpfs_is_offline(handle, fsp->fsp_name, &fsp->fsp_name->st);
1315 }
1316
1317 static ssize_t vfs_gpfs_sendfile(vfs_handle_struct *handle, int tofd,
1318                                  files_struct *fsp, const DATA_BLOB *hdr,
1319                                  SMB_OFF_T offset, size_t n)
1320 {
1321         if ((fsp->fsp_name->st.vfs_private & GPFS_WINATTR_OFFLINE) != 0) {
1322                 errno = ENOSYS;
1323                 return -1;
1324         }
1325         return SMB_VFS_NEXT_SENDFILE(handle, tofd, fsp, hdr, offset, n);
1326 }
1327
1328 int vfs_gpfs_connect(struct vfs_handle_struct *handle, const char *service,
1329                         const char *user)
1330 {
1331         struct gpfs_config_data *config;
1332
1333         smbd_gpfs_lib_init();
1334
1335         int ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
1336
1337         if (ret < 0) {
1338                 return ret;
1339         }
1340
1341         config = talloc_zero(handle->conn, struct gpfs_config_data);
1342         if (!config) {
1343                 SMB_VFS_NEXT_DISCONNECT(handle);
1344                 DEBUG(0, ("talloc_zero() failed\n"));
1345                 return -1;
1346         }
1347
1348         config->sharemodes = lp_parm_bool(SNUM(handle->conn), "gpfs",
1349                                         "sharemodes", true);
1350
1351         config->leases = lp_parm_bool(SNUM(handle->conn), "gpfs",
1352                                         "leases", true);
1353
1354         config->hsm = lp_parm_bool(SNUM(handle->conn), "gpfs",
1355                                    "hsm", false);
1356
1357         config->syncio = lp_parm_bool(SNUM(handle->conn), "gpfs",
1358                                       "syncio", false);
1359
1360         config->winattr = lp_parm_bool(SNUM(handle->conn), "gpfs",
1361                                        "winattr", false);
1362
1363         config->ftruncate = lp_parm_bool(SNUM(handle->conn), "gpfs",
1364                                          "ftruncate", true);
1365
1366         SMB_VFS_HANDLE_SET_DATA(handle, config,
1367                                 NULL, struct gpfs_config_data,
1368                                 return -1);
1369
1370         return 0;
1371 }
1372
1373 static uint32_t vfs_gpfs_capabilities(struct vfs_handle_struct *handle,
1374                                       enum timestamp_set_resolution *p_ts_res)
1375 {
1376         struct gpfs_config_data *config;
1377         uint32_t next;
1378
1379         next = SMB_VFS_NEXT_FS_CAPABILITIES(handle, p_ts_res);
1380
1381         SMB_VFS_HANDLE_GET_DATA(handle, config,
1382                                 struct gpfs_config_data,
1383                                 return next);
1384
1385         if (config->hsm) {
1386                 next |= FILE_SUPPORTS_REMOTE_STORAGE;
1387         }
1388         return next;
1389 }
1390
1391 static int vfs_gpfs_open(struct vfs_handle_struct *handle,
1392                          struct smb_filename *smb_fname, files_struct *fsp,
1393                          int flags, mode_t mode)
1394 {
1395         struct gpfs_config_data *config;
1396
1397         SMB_VFS_HANDLE_GET_DATA(handle, config,
1398                                 struct gpfs_config_data,
1399                                 return -1);
1400
1401         if (config->syncio) {
1402                 flags |= O_SYNC;
1403         }
1404         return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
1405 }
1406
1407
1408 static struct vfs_fn_pointers vfs_gpfs_fns = {
1409         .connect_fn = vfs_gpfs_connect,
1410         .fs_capabilities_fn = vfs_gpfs_capabilities,
1411         .kernel_flock_fn = vfs_gpfs_kernel_flock,
1412         .linux_setlease_fn = vfs_gpfs_setlease,
1413         .get_real_filename_fn = vfs_gpfs_get_real_filename,
1414         .fget_nt_acl_fn = gpfsacl_fget_nt_acl,
1415         .get_nt_acl_fn = gpfsacl_get_nt_acl,
1416         .fset_nt_acl_fn = gpfsacl_fset_nt_acl,
1417         .sys_acl_get_file_fn = gpfsacl_sys_acl_get_file,
1418         .sys_acl_get_fd_fn = gpfsacl_sys_acl_get_fd,
1419         .sys_acl_set_file_fn = gpfsacl_sys_acl_set_file,
1420         .sys_acl_set_fd_fn = gpfsacl_sys_acl_set_fd,
1421         .sys_acl_delete_def_file_fn = gpfsacl_sys_acl_delete_def_file,
1422         .chmod_fn = vfs_gpfs_chmod,
1423         .fchmod_fn = vfs_gpfs_fchmod,
1424         .close_fn = vfs_gpfs_close,
1425         .setxattr_fn = gpfs_set_xattr,
1426         .getxattr_fn = gpfs_get_xattr,
1427         .stat_fn = vfs_gpfs_stat,
1428         .fstat_fn = vfs_gpfs_fstat,
1429         .lstat_fn = vfs_gpfs_lstat,
1430         .ntimes_fn = vfs_gpfs_ntimes,
1431         .is_offline_fn = vfs_gpfs_is_offline,
1432         .aio_force_fn = vfs_gpfs_aio_force,
1433         .sendfile_fn = vfs_gpfs_sendfile,
1434         .open_fn = vfs_gpfs_open,
1435         .ftruncate_fn = vfs_gpfs_ftruncate
1436 };
1437
1438 NTSTATUS vfs_gpfs_init(void);
1439 NTSTATUS vfs_gpfs_init(void)
1440 {
1441         init_gpfs();
1442
1443         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "gpfs",
1444                                 &vfs_gpfs_fns);
1445 }