?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:vfs_gpfs fix memory corruption in gpfs2smb_acl
[Samba/vl.git] / source3 / modules / vfs_gpfs.c
blobf5ac7eb4fb738347d1dd5c538139d6b1dcb5a997
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 #include "auth.h"
37 #include "lib/util/tevent_unix.h"
38
39 struct gpfs_config_data {
40 bool sharemodes;
41 bool leases;
42 bool hsm;
43 bool syncio;
44 bool winattr;
45 bool ftruncate;
46 bool getrealfilename;
47 bool dfreequota;
48 bool prealloc;
49 bool acl;
50 };
51
52
53 static int vfs_gpfs_kernel_flock(vfs_handle_struct *handle, files_struct *fsp,
54 uint32 share_mode, uint32 access_mask)
55 {
56
57 struct gpfs_config_data *config;
58 int ret = 0;
59
60 SMB_VFS_HANDLE_GET_DATA(handle, config,
61 struct gpfs_config_data,
62 return -1);
63
64 if(!config->sharemodes) {
65 return 0;
66 }
67
68 START_PROFILE(syscall_kernel_flock);
69
70 kernel_flock(fsp->fh->fd, share_mode, access_mask);
71
72 if (!set_gpfs_sharemode(fsp, access_mask, fsp->share_access)) {
73 ret = -1;
74 }
75
76 END_PROFILE(syscall_kernel_flock);
77
78 return ret;
79 }
80
81 static int vfs_gpfs_close(vfs_handle_struct *handle, files_struct *fsp)
82 {
83
84 struct gpfs_config_data *config;
85
86 SMB_VFS_HANDLE_GET_DATA(handle, config,
87 struct gpfs_config_data,
88 return -1);
89
90 if (config->sharemodes && (fsp->fh != NULL) && (fsp->fh->fd != -1)) {
91 set_gpfs_sharemode(fsp, 0, 0);
92 }
93
94 return SMB_VFS_NEXT_CLOSE(handle, fsp);
95 }
96
97 static int vfs_gpfs_setlease(vfs_handle_struct *handle, files_struct *fsp,
98 int leasetype)
99 {
100 struct gpfs_config_data *config;
101 int ret=0;
102
103 SMB_VFS_HANDLE_GET_DATA(handle, config,
104 struct gpfs_config_data,
105 return -1);
106
107 if (linux_set_lease_sighandler(fsp->fh->fd) == -1)
108 return -1;
109
110 START_PROFILE(syscall_linux_setlease);
111
112 if (config->leases) {
113 ret = set_gpfs_lease(fsp->fh->fd,leasetype);
114 }
115
116 END_PROFILE(syscall_linux_setlease);
117
118 return ret;
119 }
120
121 static int vfs_gpfs_get_real_filename(struct vfs_handle_struct *handle,
122 const char *path,
123 const char *name,
124 TALLOC_CTX *mem_ctx,
125 char **found_name)
126 {
127 int result;
128 char *full_path;
129 char real_pathname[PATH_MAX+1];
130 int buflen;
131 bool mangled;
132 struct gpfs_config_data *config;
133
134 SMB_VFS_HANDLE_GET_DATA(handle, config,
135 struct gpfs_config_data,
136 return -1);
137
138 if (!config->getrealfilename) {
139 return SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name,
140 mem_ctx, found_name);
141 }
142
143 mangled = mangle_is_mangled(name, handle->conn->params);
144 if (mangled) {
145 return SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name,
146 mem_ctx, found_name);
147 }
148
149 full_path = talloc_asprintf(talloc_tos(), "%s/%s", path, name);
150 if (full_path == NULL) {
151 errno = ENOMEM;
152 return -1;
153 }
154
155 buflen = sizeof(real_pathname) - 1;
156
157 result = smbd_gpfs_get_realfilename_path(full_path, real_pathname,
158 &buflen);
159
160 TALLOC_FREE(full_path);
161
162 if ((result == -1) && (errno == ENOSYS)) {
163 return SMB_VFS_NEXT_GET_REAL_FILENAME(
164 handle, path, name, mem_ctx, found_name);
165 }
166
167 if (result == -1) {
168 DEBUG(10, ("smbd_gpfs_get_realfilename_path returned %s\n",
169 strerror(errno)));
170 return -1;
171 }
172
173 /*
174 * GPFS does not necessarily null-terminate the returned path
175 * but instead returns the buffer length in buflen.
176 */
177
178 if (buflen < sizeof(real_pathname)) {
179 real_pathname[buflen] = '\0';
180 } else {
181 real_pathname[sizeof(real_pathname)-1] = '\0';
182 }
183
184 DEBUG(10, ("smbd_gpfs_get_realfilename_path: %s/%s -> %s\n",
185 path, name, real_pathname));
186
187 name = strrchr_m(real_pathname, '/');
188 if (name == NULL) {
189 errno = ENOENT;
190 return -1;
191 }
192
193 *found_name = talloc_strdup(mem_ctx, name+1);
194 if (*found_name == NULL) {
195 errno = ENOMEM;
196 return -1;
197 }
198
199 return 0;
200 }
201
202 static void gpfs_dumpacl(int level, struct gpfs_acl *gacl)
203 {
204 gpfs_aclCount_t i;
205 if (gacl==NULL)
206 {
207 DEBUG(0, ("gpfs acl is NULL\n"));
208 return;
209 }
210
211 DEBUG(level, ("gpfs acl: nace: %d, type:%d, version:%d, level:%d, len:%d\n",
212 gacl->acl_nace, gacl->acl_type, gacl->acl_version, gacl->acl_level, gacl->acl_len));
213 for(i=0; i<gacl->acl_nace; i++)
214 {
215 struct gpfs_ace_v4 *gace = gacl->ace_v4 + i;
216 DEBUG(level, ("\tace[%d]: type:%d, flags:0x%x, mask:0x%x, iflags:0x%x, who:%u\n",
217 i, gace->aceType, gace->aceFlags, gace->aceMask,
218 gace->aceIFlags, gace->aceWho));
219 }
220 }
221
222 static struct gpfs_acl *gpfs_getacl_alloc(const char *fname, gpfs_aclType_t type)
223 {
224 struct gpfs_acl *acl;
225 size_t len = 200;
226 int ret;
227 TALLOC_CTX *mem_ctx = talloc_tos();
228
229 acl = (struct gpfs_acl *)TALLOC_SIZE(mem_ctx, len);
230 if (acl == NULL) {
231 errno = ENOMEM;
232 return NULL;
233 }
234
235 acl->acl_len = len;
236 acl->acl_level = 0;
237 acl->acl_version = 0;
238 acl->acl_type = type;
239
240 ret = smbd_gpfs_getacl((char *)fname, GPFS_GETACL_STRUCT, acl);
241 if ((ret != 0) && (errno == ENOSPC)) {
242 struct gpfs_acl *new_acl = (struct gpfs_acl *)TALLOC_SIZE(
243 mem_ctx, acl->acl_len + sizeof(struct gpfs_acl));
244 if (new_acl == NULL) {
245 talloc_free(acl);
246 errno = ENOMEM;
247 return NULL;
248 }
249
250 new_acl->acl_len = acl->acl_len;
251 new_acl->acl_level = acl->acl_level;
252 new_acl->acl_version = acl->acl_version;
253 new_acl->acl_type = acl->acl_type;
254 talloc_free(acl);
255 acl = new_acl;
256
257 ret = smbd_gpfs_getacl((char *)fname, GPFS_GETACL_STRUCT, acl);
258 }
259 if (ret != 0) {
260 DEBUG(8, ("smbd_gpfs_getacl failed with %s\n",strerror(errno)));
261 talloc_free(acl);
262 return NULL;
263 }
264
265 return acl;
266 }
267
268 /* Tries to get nfs4 acls and returns SMB ACL allocated.
269 * On failure returns 1 if it got non-NFSv4 ACL to prompt
270 * retry with POSIX ACL checks.
271 * On failure returns -1 if there is system (GPFS) error, check errno.
272 * Returns 0 on success
273 */
274 static int gpfs_get_nfs4_acl(const char *fname, SMB4ACL_T **ppacl)
275 {
276 gpfs_aclCount_t i;
277 struct gpfs_acl *gacl = NULL;
278 DEBUG(10, ("gpfs_get_nfs4_acl invoked for %s\n", fname));
279
280 /* First get the real acl length */
281 gacl = gpfs_getacl_alloc(fname, 0);
282 if (gacl == NULL) {
283 DEBUG(9, ("gpfs_getacl failed for %s with %s\n",
284 fname, strerror(errno)));
285 return -1;
286 }
287
288 if (gacl->acl_type != GPFS_ACL_TYPE_NFS4) {
289 DEBUG(10, ("Got non-nfsv4 acl\n"));
290 /* Retry with POSIX ACLs check */
291 talloc_free(gacl);
292 return 1;
293 }
294
295 *ppacl = smb_create_smb4acl();
296
297 DEBUG(10, ("len: %d, level: %d, version: %d, nace: %d\n",
298 gacl->acl_len, gacl->acl_level, gacl->acl_version,
299 gacl->acl_nace));
300
301 for (i=0; i<gacl->acl_nace; i++) {
302 struct gpfs_ace_v4 *gace = &gacl->ace_v4[i];
303 SMB_ACE4PROP_T smbace;
304 DEBUG(10, ("type: %d, iflags: %x, flags: %x, mask: %x, "
305 "who: %d\n", gace->aceType, gace->aceIFlags,
306 gace->aceFlags, gace->aceMask, gace->aceWho));
307
308 ZERO_STRUCT(smbace);
309 if (gace->aceIFlags & ACE4_IFLAG_SPECIAL_ID) {
310 smbace.flags |= SMB_ACE4_ID_SPECIAL;
311 switch (gace->aceWho) {
312 case ACE4_SPECIAL_OWNER:
313 smbace.who.special_id = SMB_ACE4_WHO_OWNER;
314 break;
315 case ACE4_SPECIAL_GROUP:
316 smbace.who.special_id = SMB_ACE4_WHO_GROUP;
317 break;
318 case ACE4_SPECIAL_EVERYONE:
319 smbace.who.special_id = SMB_ACE4_WHO_EVERYONE;
320 break;
321 default:
322 DEBUG(8, ("invalid special gpfs id %d "
323 "ignored\n", gace->aceWho));
324 continue; /* don't add it */
325 }
326 } else {
327 if (gace->aceFlags & ACE4_FLAG_GROUP_ID)
328 smbace.who.gid = gace->aceWho;
329 else
330 smbace.who.uid = gace->aceWho;
331 }
332
333 /* remove redundent deny entries */
334 if (i > 0 && gace->aceType == SMB_ACE4_ACCESS_DENIED_ACE_TYPE) {
335 struct gpfs_ace_v4 *prev = &gacl->ace_v4[i-1];
336 if (prev->aceType == SMB_ACE4_ACCESS_ALLOWED_ACE_TYPE &&
337 prev->aceFlags == gace->aceFlags &&
338 prev->aceIFlags == gace->aceIFlags &&
339 (gace->aceMask & prev->aceMask) == 0 &&
340 gace->aceWho == prev->aceWho) {
341 /* its redundent - skip it */
342 continue;
343 }
344 }
345
346 smbace.aceType = gace->aceType;
347 smbace.aceFlags = gace->aceFlags;
348 smbace.aceMask = gace->aceMask;
349 smb_add_ace4(*ppacl, &smbace);
350 }
351
352 return 0;
353 }
354
355 static NTSTATUS gpfsacl_fget_nt_acl(vfs_handle_struct *handle,
356 files_struct *fsp, uint32 security_info,
357 TALLOC_CTX *mem_ctx,
358 struct security_descriptor **ppdesc)
359 {
360 SMB4ACL_T *pacl = NULL;
361 int result;
362 struct gpfs_config_data *config;
363
364 *ppdesc = NULL;
365
366 SMB_VFS_HANDLE_GET_DATA(handle, config,
367 struct gpfs_config_data,
368 return NT_STATUS_INTERNAL_ERROR);
369
370 if (!config->acl) {
371 return SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info,
372 mem_ctx, ppdesc);
373 }
374
375 result = gpfs_get_nfs4_acl(fsp->fsp_name->base_name, &pacl);
376
377 if (result == 0)
378 return smb_fget_nt_acl_nfs4(fsp, security_info, mem_ctx, ppdesc, pacl);
379
380 if (result > 0) {
381 DEBUG(10, ("retrying with posix acl...\n"));
382 return posix_fget_nt_acl(fsp, security_info, mem_ctx, ppdesc);
383 }
384
385 /* GPFS ACL was not read, something wrong happened, error code is set in errno */
386 return map_nt_error_from_unix(errno);
387 }
388
389 static NTSTATUS gpfsacl_get_nt_acl(vfs_handle_struct *handle,
390 const char *name,
391 uint32 security_info,
392 TALLOC_CTX *mem_ctx, struct security_descriptor **ppdesc)
393 {
394 SMB4ACL_T *pacl = NULL;
395 int result;
396 struct gpfs_config_data *config;
397
398 *ppdesc = NULL;
399
400 SMB_VFS_HANDLE_GET_DATA(handle, config,
401 struct gpfs_config_data,
402 return NT_STATUS_INTERNAL_ERROR);
403
404 if (!config->acl) {
405 return SMB_VFS_NEXT_GET_NT_ACL(handle, name, security_info,
406 mem_ctx, ppdesc);
407 }
408
409 result = gpfs_get_nfs4_acl(name, &pacl);
410
411 if (result == 0)
412 return smb_get_nt_acl_nfs4(handle->conn, name, security_info,
413 mem_ctx, ppdesc, pacl);
414
415 if (result > 0) {
416 DEBUG(10, ("retrying with posix acl...\n"));
417 return posix_get_nt_acl(handle->conn, name, security_info,
418 mem_ctx, ppdesc);
419 }
420
421 /* GPFS ACL was not read, something wrong happened, error code is set in errno */
422 return map_nt_error_from_unix(errno);
423 }
424
425 static bool gpfsacl_process_smbacl(files_struct *fsp, SMB4ACL_T *smbacl)
426 {
427 int ret;
428 gpfs_aclLen_t gacl_len;
429 SMB4ACE_T *smbace;
430 struct gpfs_acl *gacl;
431 TALLOC_CTX *mem_ctx = talloc_tos();
432
433 gacl_len = offsetof(gpfs_acl_t, ace_v4) + smb_get_naces(smbacl) *
434 sizeof(gpfs_ace_v4_t);
435
436 gacl = (struct gpfs_acl *)TALLOC_SIZE(mem_ctx, gacl_len);
437 if (gacl == NULL) {
438 DEBUG(0, ("talloc failed\n"));
439 errno = ENOMEM;
440 return False;
441 }
442
443 gacl->acl_len = gacl_len;
444 gacl->acl_level = 0;
445 gacl->acl_version = GPFS_ACL_VERSION_NFS4;
446 gacl->acl_type = GPFS_ACL_TYPE_NFS4;
447 gacl->acl_nace = 0; /* change later... */
448
449 for (smbace=smb_first_ace4(smbacl); smbace!=NULL; smbace = smb_next_ace4(smbace)) {
450 struct gpfs_ace_v4 *gace = &gacl->ace_v4[gacl->acl_nace];
451 SMB_ACE4PROP_T *aceprop = smb_get_ace4(smbace);
452
453 gace->aceType = aceprop->aceType;
454 gace->aceFlags = aceprop->aceFlags;
455 gace->aceMask = aceprop->aceMask;
456
457 /*
458 * GPFS can't distinguish between WRITE and APPEND on
459 * files, so one being set without the other is an
460 * error. Sorry for the many ()'s :-)
461 */
462
463 if (!fsp->is_directory
464 &&
465 ((((gace->aceMask & ACE4_MASK_WRITE) == 0)
466 && ((gace->aceMask & ACE4_MASK_APPEND) != 0))
467 ||
468 (((gace->aceMask & ACE4_MASK_WRITE) != 0)
469 && ((gace->aceMask & ACE4_MASK_APPEND) == 0)))
470 &&
471 lp_parm_bool(fsp->conn->params->service, "gpfs",
472 "merge_writeappend", True)) {
473 DEBUG(2, ("vfs_gpfs.c: file [%s]: ACE contains "
474 "WRITE^APPEND, setting WRITE|APPEND\n",
475 fsp_str_dbg(fsp)));
476 gace->aceMask |= ACE4_MASK_WRITE|ACE4_MASK_APPEND;
477 }
478
479 gace->aceIFlags = (aceprop->flags&SMB_ACE4_ID_SPECIAL) ? ACE4_IFLAG_SPECIAL_ID : 0;
480
481 if (aceprop->flags&SMB_ACE4_ID_SPECIAL)
482 {
483 switch(aceprop->who.special_id)
484 {
485 case SMB_ACE4_WHO_EVERYONE:
486 gace->aceWho = ACE4_SPECIAL_EVERYONE;
487 break;
488 case SMB_ACE4_WHO_OWNER:
489 gace->aceWho = ACE4_SPECIAL_OWNER;
490 break;
491 case SMB_ACE4_WHO_GROUP:
492 gace->aceWho = ACE4_SPECIAL_GROUP;
493 break;
494 default:
495 DEBUG(8, ("unsupported special_id %d\n", aceprop->who.special_id));
496 continue; /* don't add it !!! */
497 }
498 } else {
499 /* just only for the type safety... */
500 if (aceprop->aceFlags&SMB_ACE4_IDENTIFIER_GROUP)
501 gace->aceWho = aceprop->who.gid;
502 else
503 gace->aceWho = aceprop->who.uid;
504 }
505
506 gacl->acl_nace++;
507 }
508
509 ret = smbd_gpfs_putacl(fsp->fsp_name->base_name,
510 GPFS_PUTACL_STRUCT | GPFS_ACL_SAMBA, gacl);
511 if (ret != 0) {
512 DEBUG(8, ("gpfs_putacl failed with %s\n", strerror(errno)));
513 gpfs_dumpacl(8, gacl);
514 return False;
515 }
516
517 DEBUG(10, ("gpfs_putacl succeeded\n"));
518 return True;
519 }
520
521 static NTSTATUS gpfsacl_set_nt_acl_internal(files_struct *fsp, uint32 security_info_sent, const struct security_descriptor *psd)
522 {
523 struct gpfs_acl *acl;
524 NTSTATUS result = NT_STATUS_ACCESS_DENIED;
525
526 acl = gpfs_getacl_alloc(fsp->fsp_name->base_name, 0);
527 if (acl == NULL)
528 return result;
529
530 if (acl->acl_version&GPFS_ACL_VERSION_NFS4)
531 {
532 if (lp_parm_bool(fsp->conn->params->service, "gpfs",
533 "refuse_dacl_protected", false)
534 && (psd->type&SEC_DESC_DACL_PROTECTED)) {
535 DEBUG(2, ("Rejecting unsupported ACL with DACL_PROTECTED bit set\n"));
536 return NT_STATUS_NOT_SUPPORTED;
537 }
538
539 result = smb_set_nt_acl_nfs4(
540 fsp, security_info_sent, psd,
541 gpfsacl_process_smbacl);
542 } else { /* assume POSIX ACL - by default... */
543 result = set_nt_acl(fsp, security_info_sent, psd);
544 }
545
546 return result;
547 }
548
549 static NTSTATUS gpfsacl_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const struct security_descriptor *psd)
550 {
551 struct gpfs_config_data *config;
552
553 SMB_VFS_HANDLE_GET_DATA(handle, config,
554 struct gpfs_config_data,
555 return NT_STATUS_INTERNAL_ERROR);
556
557 if (!config->acl) {
558 return SMB_VFS_NEXT_FSET_NT_ACL(handle, fsp, security_info_sent, psd);
559 }
560
561 return gpfsacl_set_nt_acl_internal(fsp, security_info_sent, psd);
562 }
563
564 static SMB_ACL_T gpfs2smb_acl(const struct gpfs_acl *pacl, TALLOC_CTX *mem_ctx)
565 {
566 SMB_ACL_T result;
567 gpfs_aclCount_t i;
568
569 result = sys_acl_init(mem_ctx);
570 if (result == NULL) {
571 errno = ENOMEM;
572 return NULL;
573 }
574
575 result->count = pacl->acl_nace;
576 result->acl = talloc_realloc(result, result->acl, struct smb_acl_entry,
577 result->count);
578
579 for (i=0; i<pacl->acl_nace; i++) {
580 struct smb_acl_entry *ace = &result->acl[i];
581 const struct gpfs_ace_v1 *g_ace = &pacl->ace_v1[i];
582
583 DEBUG(10, ("Converting type %d id %lu perm %x\n",
584 (int)g_ace->ace_type, (unsigned long)g_ace->ace_who,
585 (int)g_ace->ace_perm));
586
587 switch (g_ace->ace_type) {
588 case GPFS_ACL_USER:
589 ace->a_type = SMB_ACL_USER;
590 ace->info.user.uid = (uid_t)g_ace->ace_who;
591 break;
592 case GPFS_ACL_USER_OBJ:
593 ace->a_type = SMB_ACL_USER_OBJ;
594 break;
595 case GPFS_ACL_GROUP:
596 ace->a_type = SMB_ACL_GROUP;
597 ace->info.group.gid = (gid_t)g_ace->ace_who;
598 break;
599 case GPFS_ACL_GROUP_OBJ:
600 ace->a_type = SMB_ACL_GROUP_OBJ;
601 break;
602 case GPFS_ACL_OTHER:
603 ace->a_type = SMB_ACL_OTHER;
604 break;
605 case GPFS_ACL_MASK:
606 ace->a_type = SMB_ACL_MASK;
607 break;
608 default:
609 DEBUG(10, ("Got invalid ace_type: %d\n",
610 g_ace->ace_type));
611 errno = EINVAL;
612 TALLOC_FREE(result);
613 return NULL;
614 }
615
616 ace->a_perm = 0;
617 ace->a_perm |= (g_ace->ace_perm & ACL_PERM_READ) ?
618 SMB_ACL_READ : 0;
619 ace->a_perm |= (g_ace->ace_perm & ACL_PERM_WRITE) ?
620 SMB_ACL_WRITE : 0;
621 ace->a_perm |= (g_ace->ace_perm & ACL_PERM_EXECUTE) ?
622 SMB_ACL_EXECUTE : 0;
623
624 DEBUGADD(10, ("Converted to %d perm %x\n",
625 ace->a_type, ace->a_perm));
626 }
627
628 return result;
629 }
630
631 static SMB_ACL_T gpfsacl_get_posix_acl(const char *path, gpfs_aclType_t type,
632 TALLOC_CTX *mem_ctx)
633 {
634 struct gpfs_acl *pacl;
635 SMB_ACL_T result = NULL;
636
637 pacl = gpfs_getacl_alloc(path, type);
638
639 if (pacl == NULL) {
640 DEBUG(10, ("gpfs_getacl failed for %s with %s\n",
641 path, strerror(errno)));
642 if (errno == 0) {
643 errno = EINVAL;
644 }
645 goto done;
646 }
647
648 if (pacl->acl_version != GPFS_ACL_VERSION_POSIX) {
649 DEBUG(10, ("Got acl version %d, expected %d\n",
650 pacl->acl_version, GPFS_ACL_VERSION_POSIX));
651 errno = EINVAL;
652 goto done;
653 }
654
655 DEBUG(10, ("len: %d, level: %d, version: %d, nace: %d\n",
656 pacl->acl_len, pacl->acl_level, pacl->acl_version,
657 pacl->acl_nace));
658
659 result = gpfs2smb_acl(pacl, mem_ctx);
660 if (result != NULL) {
661 errno = 0;
662 }
663
664 done:
665
666 if (errno != 0) {
667 TALLOC_FREE(result);
668 }
669 return result;
670 }
671
672 static SMB_ACL_T gpfsacl_sys_acl_get_file(vfs_handle_struct *handle,
673 const char *path_p,
674 SMB_ACL_TYPE_T type,
675 TALLOC_CTX *mem_ctx)
676 {
677 gpfs_aclType_t gpfs_type;
678 struct gpfs_config_data *config;
679
680 SMB_VFS_HANDLE_GET_DATA(handle, config,
681 struct gpfs_config_data,
682 return NULL);
683
684 if (!config->acl) {
685 return SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, path_p,
686 type, mem_ctx);
687 }
688
689 switch(type) {
690 case SMB_ACL_TYPE_ACCESS:
691 gpfs_type = GPFS_ACL_TYPE_ACCESS;
692 break;
693 case SMB_ACL_TYPE_DEFAULT:
694 gpfs_type = GPFS_ACL_TYPE_DEFAULT;
695 break;
696 default:
697 DEBUG(0, ("Got invalid type: %d\n", type));
698 smb_panic("exiting");
699 }
700
701 return gpfsacl_get_posix_acl(path_p, gpfs_type, mem_ctx);
702 }
703
704 static SMB_ACL_T gpfsacl_sys_acl_get_fd(vfs_handle_struct *handle,
705 files_struct *fsp,
706 TALLOC_CTX *mem_ctx)
707 {
708 struct gpfs_config_data *config;
709
710 SMB_VFS_HANDLE_GET_DATA(handle, config,
711 struct gpfs_config_data,
712 return NULL);
713
714 if (!config->acl) {
715 return SMB_VFS_NEXT_SYS_ACL_GET_FD(handle, fsp, mem_ctx);
716 }
717
718 return gpfsacl_get_posix_acl(fsp->fsp_name->base_name,
719 GPFS_ACL_TYPE_ACCESS, mem_ctx);
720 }
721
722 static int gpfsacl_sys_acl_blob_get_file(vfs_handle_struct *handle,
723 const char *path_p,
724 TALLOC_CTX *mem_ctx,
725 char **blob_description,
726 DATA_BLOB *blob)
727 {
728 struct gpfs_config_data *config;
729 SMB4ACL_T *pacl = NULL;
730 int result;
731
732 SMB_VFS_HANDLE_GET_DATA(handle, config,
733 struct gpfs_config_data,
734 return -1);
735
736 if (!config->acl) {
737 return SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FILE(handle, path_p,
738 mem_ctx,
739 blob_description,
740 blob);
741 }
742
743 result = gpfs_get_nfs4_acl(path_p, &pacl);
744 if (result == 0) {
745 /* We don't have a way to linearlise the NFS4 ACL
746 * right now, and it is much closer to the NT ACL
747 * anyway */
748 errno = EINVAL;
749 return -1;
750 }
751
752 return posix_sys_acl_blob_get_file(handle, path_p, mem_ctx,
753 blob_description, blob);
754 }
755
756 static int gpfsacl_sys_acl_blob_get_fd(vfs_handle_struct *handle,
757 files_struct *fsp,
758 TALLOC_CTX *mem_ctx,
759 char **blob_description,
760 DATA_BLOB *blob)
761 {
762 struct gpfs_config_data *config;
763 SMB4ACL_T *pacl = NULL;
764 int result;
765
766 SMB_VFS_HANDLE_GET_DATA(handle, config,
767 struct gpfs_config_data,
768 return -1);
769
770 if (!config->acl) {
771 return SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FD(handle, fsp, mem_ctx,
772 blob_description, blob);
773 }
774
775 result = gpfs_get_nfs4_acl(fsp->fsp_name->base_name, &pacl);
776 if (result == 0) {
777 /* We don't have a way to linearlise the NFS4 ACL
778 * right now, and it is much closer to the NT ACL
779 * anyway */
780 errno = EINVAL;
781 return -1;
782 }
783
784 return posix_sys_acl_blob_get_fd(handle, fsp, mem_ctx,
785 blob_description, blob);
786 }
787
788 static struct gpfs_acl *smb2gpfs_acl(const SMB_ACL_T pacl,
789 SMB_ACL_TYPE_T type)
790 {
791 gpfs_aclLen_t len;
792 struct gpfs_acl *result;
793 int i;
794
795 DEBUG(10, ("smb2gpfs_acl: Got ACL with %d entries\n", pacl->count));
796
797 len = offsetof(gpfs_acl_t, ace_v1) + (pacl->count) *
798 sizeof(gpfs_ace_v1_t);
799
800 result = (struct gpfs_acl *)SMB_MALLOC(len);
801 if (result == NULL) {
802 errno = ENOMEM;
803 return result;
804 }
805
806 result->acl_len = len;
807 result->acl_level = 0;
808 result->acl_version = GPFS_ACL_VERSION_POSIX;
809 result->acl_type = (type == SMB_ACL_TYPE_DEFAULT) ?
810 GPFS_ACL_TYPE_DEFAULT : GPFS_ACL_TYPE_ACCESS;
811 result->acl_nace = pacl->count;
812
813 for (i=0; i<pacl->count; i++) {
814 const struct smb_acl_entry *ace = &pacl->acl[i];
815 struct gpfs_ace_v1 *g_ace = &result->ace_v1[i];
816
817 DEBUG(10, ("Converting type %d perm %x\n",
818 (int)ace->a_type, (int)ace->a_perm));
819
820 g_ace->ace_perm = 0;
821
822 switch(ace->a_type) {
823 case SMB_ACL_USER:
824 g_ace->ace_type = GPFS_ACL_USER;
825 g_ace->ace_who = (gpfs_uid_t)ace->info.user.uid;
826 break;
827 case SMB_ACL_USER_OBJ:
828 g_ace->ace_type = GPFS_ACL_USER_OBJ;
829 g_ace->ace_perm |= ACL_PERM_CONTROL;
830 g_ace->ace_who = 0;
831 break;
832 case SMB_ACL_GROUP:
833 g_ace->ace_type = GPFS_ACL_GROUP;
834 g_ace->ace_who = (gpfs_uid_t)ace->info.group.gid;
835 break;
836 case SMB_ACL_GROUP_OBJ:
837 g_ace->ace_type = GPFS_ACL_GROUP_OBJ;
838 g_ace->ace_who = 0;
839 break;
840 case SMB_ACL_MASK:
841 g_ace->ace_type = GPFS_ACL_MASK;
842 g_ace->ace_perm = 0x8f;
843 g_ace->ace_who = 0;
844 break;
845 case SMB_ACL_OTHER:
846 g_ace->ace_type = GPFS_ACL_OTHER;
847 g_ace->ace_who = 0;
848 break;
849 default:
850 DEBUG(10, ("Got invalid ace_type: %d\n", ace->a_type));
851 errno = EINVAL;
852 SAFE_FREE(result);
853 return NULL;
854 }
855
856 g_ace->ace_perm |= (ace->a_perm & SMB_ACL_READ) ?
857 ACL_PERM_READ : 0;
858 g_ace->ace_perm |= (ace->a_perm & SMB_ACL_WRITE) ?
859 ACL_PERM_WRITE : 0;
860 g_ace->ace_perm |= (ace->a_perm & SMB_ACL_EXECUTE) ?
861 ACL_PERM_EXECUTE : 0;
862
863 DEBUGADD(10, ("Converted to %d id %d perm %x\n",
864 g_ace->ace_type, g_ace->ace_who, g_ace->ace_perm));
865 }
866
867 return result;
868 }
869
870 static int gpfsacl_sys_acl_set_file(vfs_handle_struct *handle,
871 const char *name,
872 SMB_ACL_TYPE_T type,
873 SMB_ACL_T theacl)
874 {
875 struct gpfs_acl *gpfs_acl;
876 int result;
877 struct gpfs_config_data *config;
878
879 SMB_VFS_HANDLE_GET_DATA(handle, config,
880 struct gpfs_config_data,
881 return -1);
882
883 if (!config->acl) {
884 return SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, name, type, theacl);
885 }
886
887 gpfs_acl = smb2gpfs_acl(theacl, type);
888 if (gpfs_acl == NULL) {
889 return -1;
890 }
891
892 result = smbd_gpfs_putacl((char *)name, GPFS_PUTACL_STRUCT | GPFS_ACL_SAMBA, gpfs_acl);
893
894 SAFE_FREE(gpfs_acl);
895 return result;
896 }
897
898 static int gpfsacl_sys_acl_set_fd(vfs_handle_struct *handle,
899 files_struct *fsp,
900 SMB_ACL_T theacl)
901 {
902 struct gpfs_config_data *config;
903
904 SMB_VFS_HANDLE_GET_DATA(handle, config,
905 struct gpfs_config_data,
906 return -1);
907
908 if (!config->acl) {
909 return SMB_VFS_NEXT_SYS_ACL_SET_FD(handle, fsp, theacl);
910 }
911
912 return gpfsacl_sys_acl_set_file(handle, fsp->fsp_name->base_name,
913 SMB_ACL_TYPE_ACCESS, theacl);
914 }
915
916 static int gpfsacl_sys_acl_delete_def_file(vfs_handle_struct *handle,
917 const char *path)
918 {
919 struct gpfs_config_data *config;
920
921 SMB_VFS_HANDLE_GET_DATA(handle, config,
922 struct gpfs_config_data,
923 return -1);
924
925 if (!config->acl) {
926 return SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, path);
927 }
928
929 errno = ENOTSUP;
930 return -1;
931 }
932
933 /*
934 * Assumed: mode bits are shiftable and standard
935 * Output: the new aceMask field for an smb nfs4 ace
936 */
937 static uint32 gpfsacl_mask_filter(uint32 aceType, uint32 aceMask, uint32 rwx)
938 {
939 const uint32 posix_nfs4map[3] = {
940 SMB_ACE4_EXECUTE, /* execute */
941 SMB_ACE4_WRITE_DATA | SMB_ACE4_APPEND_DATA, /* write; GPFS specific */
942 SMB_ACE4_READ_DATA /* read */
943 };
944 int i;
945 uint32_t posix_mask = 0x01;
946 uint32_t posix_bit;
947 uint32_t nfs4_bits;
948
949 for(i=0; i<3; i++) {
950 nfs4_bits = posix_nfs4map[i];
951 posix_bit = rwx & posix_mask;
952
953 if (aceType==SMB_ACE4_ACCESS_ALLOWED_ACE_TYPE) {
954 if (posix_bit)
955 aceMask |= nfs4_bits;
956 else
957 aceMask &= ~nfs4_bits;
958 } else {
959 /* add deny bits when suitable */
960 if (!posix_bit)
961 aceMask |= nfs4_bits;
962 else
963 aceMask &= ~nfs4_bits;
964 } /* other ace types are unexpected */
965
966 posix_mask <<= 1;
967 }
968
969 return aceMask;
970 }
971
972 static int gpfsacl_emu_chmod(const char *path, mode_t mode)
973 {
974 SMB4ACL_T *pacl = NULL;
975 int result;
976 bool haveAllowEntry[SMB_ACE4_WHO_EVERYONE + 1] = {False, False, False, False};
977 int i;
978 files_struct fake_fsp; /* TODO: rationalize parametrization */
979 SMB4ACE_T *smbace;
980 NTSTATUS status;
981
982 DEBUG(10, ("gpfsacl_emu_chmod invoked for %s mode %o\n", path, mode));
983
984 result = gpfs_get_nfs4_acl(path, &pacl);
985 if (result)
986 return result;
987
988 if (mode & ~(S_IRWXU | S_IRWXG | S_IRWXO)) {
989 DEBUG(2, ("WARNING: cutting extra mode bits %o on %s\n", mode, path));
990 }
991
992 for (smbace=smb_first_ace4(pacl); smbace!=NULL; smbace = smb_next_ace4(smbace)) {
993 SMB_ACE4PROP_T *ace = smb_get_ace4(smbace);
994 uint32_t specid = ace->who.special_id;
995
996 if (ace->flags&SMB_ACE4_ID_SPECIAL &&
997 ace->aceType<=SMB_ACE4_ACCESS_DENIED_ACE_TYPE &&
998 specid <= SMB_ACE4_WHO_EVERYONE) {
999
1000 uint32_t newMask;
1001
1002 if (ace->aceType==SMB_ACE4_ACCESS_ALLOWED_ACE_TYPE)
1003 haveAllowEntry[specid] = True;
1004
1005 /* mode >> 6 for @owner, mode >> 3 for @group,
1006 * mode >> 0 for @everyone */
1007 newMask = gpfsacl_mask_filter(ace->aceType, ace->aceMask,
1008 mode >> ((SMB_ACE4_WHO_EVERYONE - specid) * 3));
1009 if (ace->aceMask!=newMask) {
1010 DEBUG(10, ("ace changed for %s (%o -> %o) id=%d\n",
1011 path, ace->aceMask, newMask, specid));
1012 }
1013 ace->aceMask = newMask;
1014 }
1015 }
1016
1017 /* make sure we have at least ALLOW entries
1018 * for all the 3 special ids (@EVERYONE, @OWNER, @GROUP)
1019 * - if necessary
1020 */
1021 for(i = SMB_ACE4_WHO_OWNER; i<=SMB_ACE4_WHO_EVERYONE; i++) {
1022 SMB_ACE4PROP_T ace;
1023
1024 if (haveAllowEntry[i]==True)
1025 continue;
1026
1027 ZERO_STRUCT(ace);
1028 ace.aceType = SMB_ACE4_ACCESS_ALLOWED_ACE_TYPE;
1029 ace.flags |= SMB_ACE4_ID_SPECIAL;
1030 ace.who.special_id = i;
1031
1032 if (i==SMB_ACE4_WHO_GROUP) /* not sure it's necessary... */
1033 ace.aceFlags |= SMB_ACE4_IDENTIFIER_GROUP;
1034
1035 ace.aceMask = gpfsacl_mask_filter(ace.aceType, ace.aceMask,
1036 mode >> ((SMB_ACE4_WHO_EVERYONE - i) * 3));
1037
1038 /* don't add unnecessary aces */
1039 if (!ace.aceMask)
1040 continue;
1041
1042 /* we add it to the END - as windows expects allow aces */
1043 smb_add_ace4(pacl, &ace);
1044 DEBUG(10, ("Added ALLOW ace for %s, mode=%o, id=%d, aceMask=%x\n",
1045 path, mode, i, ace.aceMask));
1046 }
1047
1048 /* don't add complementary DENY ACEs here */
1049 ZERO_STRUCT(fake_fsp);
1050 status = create_synthetic_smb_fname(talloc_tos(), path, NULL, NULL,
1051 &fake_fsp.fsp_name);
1052 if (!NT_STATUS_IS_OK(status)) {
1053 errno = map_errno_from_nt_status(status);
1054 return -1;
1055 }
1056 /* put the acl */
1057 if (gpfsacl_process_smbacl(&fake_fsp, pacl) == False) {
1058 TALLOC_FREE(fake_fsp.fsp_name);
1059 return -1;
1060 }
1061
1062 TALLOC_FREE(fake_fsp.fsp_name);
1063 return 0; /* ok for [f]chmod */
1064 }
1065
1066 static int vfs_gpfs_chmod(vfs_handle_struct *handle, const char *path, mode_t mode)
1067 {
1068 struct smb_filename *smb_fname_cpath;
1069 int rc;
1070 NTSTATUS status;
1071
1072 status = create_synthetic_smb_fname(
1073 talloc_tos(), path, NULL, NULL, &smb_fname_cpath);
1074
1075 if (SMB_VFS_NEXT_STAT(handle, smb_fname_cpath) != 0) {
1076 return -1;
1077 }
1078
1079 /* avoid chmod() if possible, to preserve acls */
1080 if ((smb_fname_cpath->st.st_ex_mode & ~S_IFMT) == mode) {
1081 return 0;
1082 }
1083
1084 rc = gpfsacl_emu_chmod(path, mode);
1085 if (rc == 1)
1086 return SMB_VFS_NEXT_CHMOD(handle, path, mode);
1087 return rc;
1088 }
1089
1090 static int vfs_gpfs_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
1091 {
1092 SMB_STRUCT_STAT st;
1093 int rc;
1094
1095 if (SMB_VFS_NEXT_FSTAT(handle, fsp, &st) != 0) {
1096 return -1;
1097 }
1098
1099 /* avoid chmod() if possible, to preserve acls */
1100 if ((st.st_ex_mode & ~S_IFMT) == mode) {
1101 return 0;
1102 }
1103
1104 rc = gpfsacl_emu_chmod(fsp->fsp_name->base_name, mode);
1105 if (rc == 1)
1106 return SMB_VFS_NEXT_FCHMOD(handle, fsp, mode);
1107 return rc;
1108 }
1109
1110 static int gpfs_set_xattr(struct vfs_handle_struct *handle, const char *path,
1111 const char *name, const void *value, size_t size, int flags){
1112 struct xattr_DOSATTRIB dosattrib;
1113 enum ndr_err_code ndr_err;
1114 DATA_BLOB blob;
1115 const char *attrstr = value;
1116 unsigned int dosmode=0;
1117 struct gpfs_winattr attrs;
1118 int ret = 0;
1119 struct gpfs_config_data *config;
1120
1121 SMB_VFS_HANDLE_GET_DATA(handle, config,
1122 struct gpfs_config_data,
1123 return -1);
1124
1125 if (!config->winattr) {
1126 DEBUG(10, ("gpfs_set_xattr:name is %s -> next\n",name));
1127 return SMB_VFS_NEXT_SETXATTR(handle,path,name,value,size,flags);
1128 }
1129
1130 DEBUG(10, ("gpfs_set_xattr: %s \n",path));
1131
1132 /* Only handle DOS Attributes */
1133 if (strcmp(name,SAMBA_XATTR_DOS_ATTRIB) != 0){
1134 DEBUG(5, ("gpfs_set_xattr:name is %s\n",name));
1135 return SMB_VFS_NEXT_SETXATTR(handle,path,name,value,size,flags);
1136 }
1137
1138 blob.data = (uint8_t *)attrstr;
1139 blob.length = size;
1140
1141 ndr_err = ndr_pull_struct_blob(&blob, talloc_tos(), &dosattrib,
1142 (ndr_pull_flags_fn_t)ndr_pull_xattr_DOSATTRIB);
1143
1144 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1145 DEBUG(1, ("gpfs_set_xattr: bad ndr decode "
1146 "from EA on file %s: Error = %s\n",
1147 path, ndr_errstr(ndr_err)));
1148 return false;
1149 }
1150
1151 if (dosattrib.version != 3) {
1152 DEBUG(1, ("gpfs_set_xattr: expected dosattrib version 3, got "
1153 "%d\n", (int)dosattrib.version));
1154 return false;
1155 }
1156 if (!(dosattrib.info.info3.valid_flags & XATTR_DOSINFO_ATTRIB)) {
1157 DEBUG(10, ("gpfs_set_xattr: XATTR_DOSINFO_ATTRIB not "
1158 "valid, ignoring\n"));
1159 return true;
1160 }
1161
1162 dosmode = dosattrib.info.info3.attrib;
1163
1164 attrs.winAttrs = 0;
1165 /*Just map RD_ONLY, ARCHIVE, SYSTEM HIDDEN and SPARSE. Ignore the others*/
1166 if (dosmode & FILE_ATTRIBUTE_ARCHIVE){
1167 attrs.winAttrs |= GPFS_WINATTR_ARCHIVE;
1168 }
1169 if (dosmode & FILE_ATTRIBUTE_HIDDEN){
1170 attrs.winAttrs |= GPFS_WINATTR_HIDDEN;
1171 }
1172 if (dosmode & FILE_ATTRIBUTE_SYSTEM){
1173 attrs.winAttrs |= GPFS_WINATTR_SYSTEM;
1174 }
1175 if (dosmode & FILE_ATTRIBUTE_READONLY){
1176 attrs.winAttrs |= GPFS_WINATTR_READONLY;
1177 }
1178 if (dosmode & FILE_ATTRIBUTE_SPARSE) {
1179 attrs.winAttrs |= GPFS_WINATTR_SPARSE_FILE;
1180 }
1181
1182
1183 ret = set_gpfs_winattrs(discard_const_p(char, path),
1184 GPFS_WINATTR_SET_ATTRS, &attrs);
1185 if ( ret == -1){
1186 if (errno == ENOSYS) {
1187 return SMB_VFS_NEXT_SETXATTR(handle, path, name, value,
1188 size, flags);
1189 }
1190
1191 DEBUG(1, ("gpfs_set_xattr:Set GPFS attributes failed %d\n",ret));
1192 return -1;
1193 }
1194
1195 DEBUG(10, ("gpfs_set_xattr:Set attributes: 0x%x\n",attrs.winAttrs));
1196 return 0;
1197 }
1198
1199 static ssize_t gpfs_get_xattr(struct vfs_handle_struct *handle, const char *path,
1200 const char *name, void *value, size_t size){
1201 char *attrstr = value;
1202 unsigned int dosmode = 0;
1203 struct gpfs_winattr attrs;
1204 int ret = 0;
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 if (!config->winattr) {
1212 DEBUG(10, ("gpfs_get_xattr:name is %s -> next\n",name));
1213 return SMB_VFS_NEXT_GETXATTR(handle,path,name,value,size);
1214 }
1215
1216 DEBUG(10, ("gpfs_get_xattr: %s \n",path));
1217
1218 /* Only handle DOS Attributes */
1219 if (strcmp(name,SAMBA_XATTR_DOS_ATTRIB) != 0){
1220 DEBUG(5, ("gpfs_get_xattr:name is %s\n",name));
1221 return SMB_VFS_NEXT_GETXATTR(handle,path,name,value,size);
1222 }
1223
1224 ret = get_gpfs_winattrs(discard_const_p(char, path), &attrs);
1225 if ( ret == -1){
1226 if (errno == ENOSYS) {
1227 return SMB_VFS_NEXT_GETXATTR(handle, path, name, value,
1228 size);
1229 }
1230
1231 DEBUG(1, ("gpfs_get_xattr: Get GPFS attributes failed: "
1232 "%d (%s)\n", ret, strerror(errno)));
1233 return -1;
1234 }
1235
1236 DEBUG(10, ("gpfs_get_xattr:Got attributes: 0x%x\n",attrs.winAttrs));
1237
1238 /*Just map RD_ONLY, ARCHIVE, SYSTEM, HIDDEN and SPARSE. Ignore the others*/
1239 if (attrs.winAttrs & GPFS_WINATTR_ARCHIVE){
1240 dosmode |= FILE_ATTRIBUTE_ARCHIVE;
1241 }
1242 if (attrs.winAttrs & GPFS_WINATTR_HIDDEN){
1243 dosmode |= FILE_ATTRIBUTE_HIDDEN;
1244 }
1245 if (attrs.winAttrs & GPFS_WINATTR_SYSTEM){
1246 dosmode |= FILE_ATTRIBUTE_SYSTEM;
1247 }
1248 if (attrs.winAttrs & GPFS_WINATTR_READONLY){
1249 dosmode |= FILE_ATTRIBUTE_READONLY;
1250 }
1251 if (attrs.winAttrs & GPFS_WINATTR_SPARSE_FILE) {
1252 dosmode |= FILE_ATTRIBUTE_SPARSE;
1253 }
1254
1255 snprintf(attrstr, size, "0x%2.2x",
1256 (unsigned int)(dosmode & SAMBA_ATTRIBUTES_MASK));
1257 DEBUG(10, ("gpfs_get_xattr: returning %s\n",attrstr));
1258 return 4;
1259 }
1260
1261 static int vfs_gpfs_stat(struct vfs_handle_struct *handle,
1262 struct smb_filename *smb_fname)
1263 {
1264 struct gpfs_winattr attrs;
1265 char *fname = NULL;
1266 NTSTATUS status;
1267 int ret;
1268 struct gpfs_config_data *config;
1269
1270 SMB_VFS_HANDLE_GET_DATA(handle, config,
1271 struct gpfs_config_data,
1272 return -1);
1273
1274 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
1275 if (ret == -1) {
1276 return -1;
1277 }
1278
1279 if (!config->winattr) {
1280 return 0;
1281 }
1282
1283 status = get_full_smb_filename(talloc_tos(), smb_fname, &fname);
1284 if (!NT_STATUS_IS_OK(status)) {
1285 errno = map_errno_from_nt_status(status);
1286 return -1;
1287 }
1288 ret = get_gpfs_winattrs(discard_const_p(char, fname), &attrs);
1289 TALLOC_FREE(fname);
1290 if (ret == 0) {
1291 smb_fname->st.st_ex_calculated_birthtime = false;
1292 smb_fname->st.st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
1293 smb_fname->st.st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
1294 smb_fname->st.vfs_private = attrs.winAttrs;
1295 }
1296 return 0;
1297 }
1298
1299 static int vfs_gpfs_fstat(struct vfs_handle_struct *handle,
1300 struct files_struct *fsp, SMB_STRUCT_STAT *sbuf)
1301 {
1302 struct gpfs_winattr attrs;
1303 int ret;
1304 struct gpfs_config_data *config;
1305
1306 SMB_VFS_HANDLE_GET_DATA(handle, config,
1307 struct gpfs_config_data,
1308 return -1);
1309
1310 ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
1311 if (ret == -1) {
1312 return -1;
1313 }
1314 if ((fsp->fh == NULL) || (fsp->fh->fd == -1)) {
1315 return 0;
1316 }
1317 if (!config->winattr) {
1318 return 0;
1319 }
1320
1321 ret = smbd_fget_gpfs_winattrs(fsp->fh->fd, &attrs);
1322 if (ret == 0) {
1323 sbuf->st_ex_calculated_birthtime = false;
1324 sbuf->st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
1325 sbuf->st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
1326 }
1327 return 0;
1328 }
1329
1330 static int vfs_gpfs_lstat(struct vfs_handle_struct *handle,
1331 struct smb_filename *smb_fname)
1332 {
1333 struct gpfs_winattr attrs;
1334 char *path = NULL;
1335 NTSTATUS status;
1336 int ret;
1337 struct gpfs_config_data *config;
1338
1339 SMB_VFS_HANDLE_GET_DATA(handle, config,
1340 struct gpfs_config_data,
1341 return -1);
1342
1343 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
1344 if (ret == -1) {
1345 return -1;
1346 }
1347 if (!config->winattr) {
1348 return 0;
1349 }
1350
1351 status = get_full_smb_filename(talloc_tos(), smb_fname, &path);
1352 if (!NT_STATUS_IS_OK(status)) {
1353 errno = map_errno_from_nt_status(status);
1354 return -1;
1355 }
1356 ret = get_gpfs_winattrs(discard_const_p(char, path), &attrs);
1357 TALLOC_FREE(path);
1358 if (ret == 0) {
1359 smb_fname->st.st_ex_calculated_birthtime = false;
1360 smb_fname->st.st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
1361 smb_fname->st.st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
1362 smb_fname->st.vfs_private = attrs.winAttrs;
1363 }
1364 return 0;
1365 }
1366
1367 static int vfs_gpfs_ntimes(struct vfs_handle_struct *handle,
1368 const struct smb_filename *smb_fname,
1369 struct smb_file_time *ft)
1370 {
1371
1372 struct gpfs_winattr attrs;
1373 int ret;
1374 char *path = NULL;
1375 NTSTATUS status;
1376 struct gpfs_config_data *config;
1377
1378 SMB_VFS_HANDLE_GET_DATA(handle, config,
1379 struct gpfs_config_data,
1380 return -1);
1381
1382 ret = SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
1383 if(ret == -1){
1384 /* don't complain if access was denied */
1385 if (errno != EPERM && errno != EACCES) {
1386 DEBUG(1,("vfs_gpfs_ntimes: SMB_VFS_NEXT_NTIMES failed:"
1387 "%s", strerror(errno)));
1388 }
1389 return -1;
1390 }
1391
1392 if(null_timespec(ft->create_time)){
1393 DEBUG(10,("vfs_gpfs_ntimes:Create Time is NULL\n"));
1394 return 0;
1395 }
1396
1397 if (!config->winattr) {
1398 return 0;
1399 }
1400
1401 status = get_full_smb_filename(talloc_tos(), smb_fname, &path);
1402 if (!NT_STATUS_IS_OK(status)) {
1403 errno = map_errno_from_nt_status(status);
1404 return -1;
1405 }
1406
1407 attrs.winAttrs = 0;
1408 attrs.creationTime.tv_sec = ft->create_time.tv_sec;
1409 attrs.creationTime.tv_nsec = ft->create_time.tv_nsec;
1410
1411 ret = set_gpfs_winattrs(discard_const_p(char, path),
1412 GPFS_WINATTR_SET_CREATION_TIME, &attrs);
1413 if(ret == -1 && errno != ENOSYS){
1414 DEBUG(1,("vfs_gpfs_ntimes: set GPFS ntimes failed %d\n",ret));
1415 return -1;
1416 }
1417 return 0;
1418
1419 }
1420
1421 static int vfs_gpfs_fallocate(struct vfs_handle_struct *handle,
1422 struct files_struct *fsp, enum vfs_fallocate_mode mode,
1423 off_t offset, off_t len)
1424 {
1425 int ret;
1426 struct gpfs_config_data *config;
1427
1428 SMB_VFS_HANDLE_GET_DATA(handle, config,
1429 struct gpfs_config_data,
1430 return -1);
1431
1432 if (!config->prealloc) {
1433 /* you should better not run fallocate() on GPFS at all */
1434 errno = ENOTSUP;
1435 return -1;
1436 }
1437
1438 if (mode == VFS_FALLOCATE_KEEP_SIZE) {
1439 DEBUG(10, ("Unsupported VFS_FALLOCATE_KEEP_SIZE\n"));
1440 errno = ENOTSUP;
1441 return -1;
1442 }
1443
1444 ret = smbd_gpfs_prealloc(fsp->fh->fd, offset, len);
1445
1446 if (ret == -1 && errno != ENOSYS) {
1447 DEBUG(0, ("GPFS prealloc failed: %s\n", strerror(errno)));
1448 } else if (ret == -1 && errno == ENOSYS) {
1449 DEBUG(10, ("GPFS prealloc not supported.\n"));
1450 } else {
1451 DEBUG(10, ("GPFS prealloc succeeded.\n"));
1452 }
1453
1454 return ret;
1455 }
1456
1457 static int vfs_gpfs_ftruncate(vfs_handle_struct *handle, files_struct *fsp,
1458 off_t len)
1459 {
1460 int result;
1461 struct gpfs_config_data *config;
1462
1463 SMB_VFS_HANDLE_GET_DATA(handle, config,
1464 struct gpfs_config_data,
1465 return -1);
1466
1467 if (!config->ftruncate) {
1468 return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, len);
1469 }
1470
1471 result = smbd_gpfs_ftruncate(fsp->fh->fd, len);
1472 if ((result == -1) && (errno == ENOSYS)) {
1473 return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, len);
1474 }
1475 return result;
1476 }
1477
1478 static bool vfs_gpfs_is_offline(struct vfs_handle_struct *handle,
1479 const struct smb_filename *fname,
1480 SMB_STRUCT_STAT *sbuf)
1481 {
1482 struct gpfs_winattr attrs;
1483 char *path = NULL;
1484 NTSTATUS status;
1485 struct gpfs_config_data *config;
1486
1487 SMB_VFS_HANDLE_GET_DATA(handle, config,
1488 struct gpfs_config_data,
1489 return -1);
1490
1491 if (!config->winattr) {
1492 return SMB_VFS_NEXT_IS_OFFLINE(handle, fname, sbuf);
1493 }
1494
1495 status = get_full_smb_filename(talloc_tos(), fname, &path);
1496 if (!NT_STATUS_IS_OK(status)) {
1497 errno = map_errno_from_nt_status(status);
1498 return -1;
1499 }
1500
1501 if (VALID_STAT(*sbuf)) {
1502 attrs.winAttrs = sbuf->vfs_private;
1503 } else {
1504 int ret;
1505 ret = get_gpfs_winattrs(path, &attrs);
1506
1507 if (ret == -1) {
1508 TALLOC_FREE(path);
1509 return false;
1510 }
1511 }
1512 if ((attrs.winAttrs & GPFS_WINATTR_OFFLINE) != 0) {
1513 DEBUG(10, ("%s is offline\n", path));
1514 TALLOC_FREE(path);
1515 return true;
1516 }
1517 DEBUG(10, ("%s is online\n", path));
1518 TALLOC_FREE(path);
1519 return SMB_VFS_NEXT_IS_OFFLINE(handle, fname, sbuf);
1520 }
1521
1522 static bool vfs_gpfs_aio_force(struct vfs_handle_struct *handle,
1523 struct files_struct *fsp)
1524 {
1525 return vfs_gpfs_is_offline(handle, fsp->fsp_name, &fsp->fsp_name->st);
1526 }
1527
1528 static ssize_t vfs_gpfs_sendfile(vfs_handle_struct *handle, int tofd,
1529 files_struct *fsp, const DATA_BLOB *hdr,
1530 off_t offset, size_t n)
1531 {
1532 if ((fsp->fsp_name->st.vfs_private & GPFS_WINATTR_OFFLINE) != 0) {
1533 errno = ENOSYS;
1534 return -1;
1535 }
1536 return SMB_VFS_NEXT_SENDFILE(handle, tofd, fsp, hdr, offset, n);
1537 }
1538
1539 static int vfs_gpfs_connect(struct vfs_handle_struct *handle,
1540 const char *service, const char *user)
1541 {
1542 struct gpfs_config_data *config;
1543 int ret;
1544
1545 smbd_gpfs_lib_init();
1546
1547 ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
1548
1549 if (ret < 0) {
1550 return ret;
1551 }
1552
1553 config = talloc_zero(handle->conn, struct gpfs_config_data);
1554 if (!config) {
1555 SMB_VFS_NEXT_DISCONNECT(handle);
1556 DEBUG(0, ("talloc_zero() failed\n"));
1557 return -1;
1558 }
1559
1560 config->sharemodes = lp_parm_bool(SNUM(handle->conn), "gpfs",
1561 "sharemodes", true);
1562
1563 config->leases = lp_parm_bool(SNUM(handle->conn), "gpfs",
1564 "leases", true);
1565
1566 config->hsm = lp_parm_bool(SNUM(handle->conn), "gpfs",
1567 "hsm", false);
1568
1569 config->syncio = lp_parm_bool(SNUM(handle->conn), "gpfs",
1570 "syncio", false);
1571
1572 config->winattr = lp_parm_bool(SNUM(handle->conn), "gpfs",
1573 "winattr", false);
1574
1575 config->ftruncate = lp_parm_bool(SNUM(handle->conn), "gpfs",
1576 "ftruncate", true);
1577
1578 config->getrealfilename = lp_parm_bool(SNUM(handle->conn), "gpfs",
1579 "getrealfilename", true);
1580
1581 config->dfreequota = lp_parm_bool(SNUM(handle->conn), "gpfs",
1582 "dfreequota", false);
1583
1584 config->prealloc = lp_parm_bool(SNUM(handle->conn), "gpfs",
1585 "prealloc", true);
1586
1587 config->acl = lp_parm_bool(SNUM(handle->conn), "gpfs", "acl", true);
1588
1589 SMB_VFS_HANDLE_SET_DATA(handle, config,
1590 NULL, struct gpfs_config_data,
1591 return -1);
1592
1593 if (config->leases) {
1594 /*
1595 * GPFS lease code is based on kernel oplock code
1596 * so make sure it is turned on
1597 */
1598 if (!lp_kernel_oplocks(SNUM(handle->conn))) {
1599 DEBUG(5, ("Enabling kernel oplocks for "
1600 "gpfs:leases to work\n"));
1601 lp_do_parameter(SNUM(handle->conn), "kernel oplocks",
1602 "true");
1603 }
1604
1605 /*
1606 * as the kernel does not properly support Level II oplocks
1607 * and GPFS leases code is based on kernel infrastructure, we
1608 * need to turn off Level II oplocks if gpfs:leases is enabled
1609 */
1610 if (lp_level2_oplocks(SNUM(handle->conn))) {
1611 DEBUG(5, ("gpfs:leases are enabled, disabling "
1612 "Level II oplocks\n"));
1613 lp_do_parameter(SNUM(handle->conn), "level2 oplocks",
1614 "false");
1615 }
1616 }
1617
1618 return 0;
1619 }
1620
1621 static int vfs_gpfs_get_quotas(const char *path, uid_t uid, gid_t gid,
1622 int *fset_id,
1623 struct gpfs_quotaInfo *qi_user,
1624 struct gpfs_quotaInfo *qi_group,
1625 struct gpfs_quotaInfo *qi_fset)
1626 {
1627 int err;
1628 char *dir_path;
1629 bool b;
1630
1631 /*
1632 * We want to always use the directory to get the fileset id,
1633 * because files might have a share mode. We also do not want
1634 * to get the parent directory when there is already a
1635 * directory to avoid stepping in a different fileset. The
1636 * path passed here is currently either "." or a filename, so
1637 * this is ok. The proper solution would be having a way to
1638 * query the fileset id without opening the file.
1639 */
1640 b = parent_dirname(talloc_tos(), path, &dir_path, NULL);
1641 if (!b) {
1642 errno = ENOMEM;
1643 return -1;
1644 }
1645
1646 DEBUG(10, ("path %s, directory %s\n", path, dir_path));
1647
1648 err = get_gpfs_fset_id(dir_path, fset_id);
1649 if (err) {
1650 DEBUG(0, ("Get fset id failed path %s, dir %s, errno %d.\n",
1651 path, dir_path, errno));
1652 return err;
1653 }
1654
1655 err = get_gpfs_quota(path, GPFS_USRQUOTA, uid, qi_user);
1656 if (err) {
1657 return err;
1658 }
1659
1660 err = get_gpfs_quota(path, GPFS_GRPQUOTA, gid, qi_group);
1661 if (err) {
1662 return err;
1663 }
1664
1665 err = get_gpfs_quota(path, GPFS_FILESETQUOTA, *fset_id, qi_fset);
1666 if (err) {
1667 return err;
1668 }
1669
1670 return 0;
1671 }
1672
1673 static void vfs_gpfs_disk_free_quota(struct gpfs_quotaInfo qi, time_t cur_time,
1674 uint64_t *dfree, uint64_t *dsize)
1675 {
1676 uint64_t usage, limit;
1677
1678 /*
1679 * The quota reporting is done in units of 1024 byte blocks, but
1680 * sys_fsusage uses units of 512 byte blocks, adjust the block number
1681 * accordingly. Also filter possibly negative usage counts from gpfs.
1682 */
1683 usage = qi.blockUsage < 0 ? 0 : (uint64_t)qi.blockUsage * 2;
1684 limit = (uint64_t)qi.blockHardLimit * 2;
1685
1686 /*
1687 * When the grace time for the exceeded soft block quota has been
1688 * exceeded, the soft block quota becomes an additional hard limit.
1689 */
1690 if (qi.blockSoftLimit &&
1691 qi.blockGraceTime && cur_time > qi.blockGraceTime) {
1692 /* report disk as full */
1693 *dfree = 0;
1694 *dsize = MIN(*dsize, usage);
1695 }
1696
1697 if (!qi.blockHardLimit)
1698 return;
1699
1700 if (usage >= limit) {
1701 /* report disk as full */
1702 *dfree = 0;
1703 *dsize = MIN(*dsize, usage);
1704
1705 } else {
1706 /* limit has not been reached, determine "free space" */
1707 *dfree = MIN(*dfree, limit - usage);
1708 *dsize = MIN(*dsize, limit);
1709 }
1710 }
1711
1712 static uint64_t vfs_gpfs_disk_free(vfs_handle_struct *handle, const char *path,
1713 bool small_query, uint64_t *bsize,
1714 uint64_t *dfree, uint64_t *dsize)
1715 {
1716 struct security_unix_token *utok;
1717 struct gpfs_quotaInfo qi_user, qi_group, qi_fset;
1718 struct gpfs_config_data *config;
1719 int err, fset_id;
1720 time_t cur_time;
1721
1722 SMB_VFS_HANDLE_GET_DATA(handle, config, struct gpfs_config_data,
1723 return (uint64_t)-1);
1724 if (!config->dfreequota) {
1725 return SMB_VFS_NEXT_DISK_FREE(handle, path, small_query,
1726 bsize, dfree, dsize);
1727 }
1728
1729 err = sys_fsusage(path, dfree, dsize);
1730 if (err) {
1731 DEBUG (0, ("Could not get fs usage, errno %d\n", errno));
1732 return SMB_VFS_NEXT_DISK_FREE(handle, path, small_query,
1733 bsize, dfree, dsize);
1734 }
1735
1736 /* sys_fsusage returns units of 512 bytes */
1737 *bsize = 512;
1738
1739 DEBUG(10, ("fs dfree %llu, dsize %llu\n",
1740 (unsigned long long)*dfree, (unsigned long long)*dsize));
1741
1742 utok = handle->conn->session_info->unix_token;
1743 err = vfs_gpfs_get_quotas(path, utok->uid, utok->gid, &fset_id,
1744 &qi_user, &qi_group, &qi_fset);
1745 if (err) {
1746 return SMB_VFS_NEXT_DISK_FREE(handle, path, small_query,
1747 bsize, dfree, dsize);
1748 }
1749
1750 cur_time = time(NULL);
1751
1752 /* Adjust free space and size according to quota limits. */
1753 vfs_gpfs_disk_free_quota(qi_user, cur_time, dfree, dsize);
1754 vfs_gpfs_disk_free_quota(qi_group, cur_time, dfree, dsize);
1755
1756 /* Id 0 indicates the default quota, not an actual quota */
1757 if (fset_id != 0) {
1758 vfs_gpfs_disk_free_quota(qi_fset, cur_time, dfree, dsize);
1759 }
1760
1761 disk_norm(small_query, bsize, dfree, dsize);
1762 return *dfree;
1763 }
1764
1765 static uint32_t vfs_gpfs_capabilities(struct vfs_handle_struct *handle,
1766 enum timestamp_set_resolution *p_ts_res)
1767 {
1768 struct gpfs_config_data *config;
1769 uint32_t next;
1770
1771 next = SMB_VFS_NEXT_FS_CAPABILITIES(handle, p_ts_res);
1772
1773 SMB_VFS_HANDLE_GET_DATA(handle, config,
1774 struct gpfs_config_data,
1775 return next);
1776
1777 if (config->hsm) {
1778 next |= FILE_SUPPORTS_REMOTE_STORAGE;
1779 }
1780 return next;
1781 }
1782
1783 static int vfs_gpfs_open(struct vfs_handle_struct *handle,
1784 struct smb_filename *smb_fname, files_struct *fsp,
1785 int flags, mode_t mode)
1786 {
1787 struct gpfs_config_data *config;
1788
1789 SMB_VFS_HANDLE_GET_DATA(handle, config,
1790 struct gpfs_config_data,
1791 return -1);
1792
1793 if (config->syncio) {
1794 flags |= O_SYNC;
1795 }
1796 return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
1797 }
1798
1799 static ssize_t vfs_gpfs_pread(vfs_handle_struct *handle, files_struct *fsp,
1800 void *data, size_t n, off_t offset)
1801 {
1802 ssize_t ret;
1803
1804 ret = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
1805
1806 DEBUG(10, ("vfs_private = %x\n",
1807 (unsigned int)fsp->fsp_name->st.vfs_private));
1808
1809 if ((ret != -1) &&
1810 ((fsp->fsp_name->st.vfs_private & GPFS_WINATTR_OFFLINE) != 0)) {
1811 fsp->fsp_name->st.vfs_private &= ~GPFS_WINATTR_OFFLINE;
1812 notify_fname(handle->conn, NOTIFY_ACTION_MODIFIED,
1813 FILE_NOTIFY_CHANGE_ATTRIBUTES,
1814 fsp->fsp_name->base_name);
1815 }
1816
1817 return ret;
1818 }
1819
1820 struct vfs_gpfs_pread_state {
1821 struct files_struct *fsp;
1822 ssize_t ret;
1823 int err;
1824 };
1825
1826 static void vfs_gpfs_pread_done(struct tevent_req *subreq);
1827
1828 static struct tevent_req *vfs_gpfs_pread_send(struct vfs_handle_struct *handle,
1829 TALLOC_CTX *mem_ctx,
1830 struct tevent_context *ev,
1831 struct files_struct *fsp,
1832 void *data, size_t n,
1833 off_t offset)
1834 {
1835 struct tevent_req *req, *subreq;
1836 struct vfs_gpfs_pread_state *state;
1837
1838 req = tevent_req_create(mem_ctx, &state, struct vfs_gpfs_pread_state);
1839 if (req == NULL) {
1840 return NULL;
1841 }
1842 state->fsp = fsp;
1843 subreq = SMB_VFS_NEXT_PREAD_SEND(state, ev, handle, fsp, data,
1844 n, offset);
1845 if (tevent_req_nomem(subreq, req)) {
1846 return tevent_req_post(req, ev);
1847 }
1848 tevent_req_set_callback(subreq, vfs_gpfs_pread_done, req);
1849 return req;
1850 }
1851
1852 static void vfs_gpfs_pread_done(struct tevent_req *subreq)
1853 {
1854 struct tevent_req *req = tevent_req_callback_data(
1855 subreq, struct tevent_req);
1856 struct vfs_gpfs_pread_state *state = tevent_req_data(
1857 req, struct vfs_gpfs_pread_state);
1858
1859 state->ret = SMB_VFS_PREAD_RECV(subreq, &state->err);
1860 TALLOC_FREE(subreq);
1861 tevent_req_done(req);
1862 }
1863
1864 static ssize_t vfs_gpfs_pread_recv(struct tevent_req *req, int *err)
1865 {
1866 struct vfs_gpfs_pread_state *state = tevent_req_data(
1867 req, struct vfs_gpfs_pread_state);
1868 struct files_struct *fsp = state->fsp;
1869
1870 if (tevent_req_is_unix_error(req, err)) {
1871 return -1;
1872 }
1873 *err = state->err;
1874
1875 DEBUG(10, ("vfs_private = %x\n",
1876 (unsigned int)fsp->fsp_name->st.vfs_private));
1877
1878 if ((state->ret != -1) &&
1879 ((fsp->fsp_name->st.vfs_private & GPFS_WINATTR_OFFLINE) != 0)) {
1880 fsp->fsp_name->st.vfs_private &= ~GPFS_WINATTR_OFFLINE;
1881 DEBUG(10, ("sending notify\n"));
1882 notify_fname(fsp->conn, NOTIFY_ACTION_MODIFIED,
1883 FILE_NOTIFY_CHANGE_ATTRIBUTES,
1884 fsp->fsp_name->base_name);
1885 }
1886
1887 return state->ret;
1888 }
1889
1890 static ssize_t vfs_gpfs_pwrite(vfs_handle_struct *handle, files_struct *fsp,
1891 const void *data, size_t n, off_t offset)
1892 {
1893 ssize_t ret;
1894
1895 ret = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
1896
1897 DEBUG(10, ("vfs_private = %x\n",
1898 (unsigned int)fsp->fsp_name->st.vfs_private));
1899
1900 if ((ret != -1) &&
1901 ((fsp->fsp_name->st.vfs_private & GPFS_WINATTR_OFFLINE) != 0)) {
1902 fsp->fsp_name->st.vfs_private &= ~GPFS_WINATTR_OFFLINE;
1903 notify_fname(handle->conn, NOTIFY_ACTION_MODIFIED,
1904 FILE_NOTIFY_CHANGE_ATTRIBUTES,
1905 fsp->fsp_name->base_name);
1906 }
1907
1908 return ret;
1909 }
1910
1911 struct vfs_gpfs_pwrite_state {
1912 struct files_struct *fsp;
1913 ssize_t ret;
1914 int err;
1915 };
1916
1917 static void vfs_gpfs_pwrite_done(struct tevent_req *subreq);
1918
1919 static struct tevent_req *vfs_gpfs_pwrite_send(
1920 struct vfs_handle_struct *handle,
1921 TALLOC_CTX *mem_ctx,
1922 struct tevent_context *ev,
1923 struct files_struct *fsp,
1924 const void *data, size_t n,
1925 off_t offset)
1926 {
1927 struct tevent_req *req, *subreq;
1928 struct vfs_gpfs_pwrite_state *state;
1929
1930 req = tevent_req_create(mem_ctx, &state, struct vfs_gpfs_pwrite_state);
1931 if (req == NULL) {
1932 return NULL;
1933 }
1934 state->fsp = fsp;
1935 subreq = SMB_VFS_NEXT_PWRITE_SEND(state, ev, handle, fsp, data,
1936 n, offset);
1937 if (tevent_req_nomem(subreq, req)) {
1938 return tevent_req_post(req, ev);
1939 }
1940 tevent_req_set_callback(subreq, vfs_gpfs_pwrite_done, req);
1941 return req;
1942 }
1943
1944 static void vfs_gpfs_pwrite_done(struct tevent_req *subreq)
1945 {
1946 struct tevent_req *req = tevent_req_callback_data(
1947 subreq, struct tevent_req);
1948 struct vfs_gpfs_pwrite_state *state = tevent_req_data(
1949 req, struct vfs_gpfs_pwrite_state);
1950
1951 state->ret = SMB_VFS_PWRITE_RECV(subreq, &state->err);
1952 TALLOC_FREE(subreq);
1953 tevent_req_done(req);
1954 }
1955
1956 static ssize_t vfs_gpfs_pwrite_recv(struct tevent_req *req, int *err)
1957 {
1958 struct vfs_gpfs_pwrite_state *state = tevent_req_data(
1959 req, struct vfs_gpfs_pwrite_state);
1960 struct files_struct *fsp = state->fsp;
1961
1962 if (tevent_req_is_unix_error(req, err)) {
1963 return -1;
1964 }
1965 *err = state->err;
1966
1967 DEBUG(10, ("vfs_private = %x\n",
1968 (unsigned int)fsp->fsp_name->st.vfs_private));
1969
1970 if ((state->ret != -1) &&
1971 ((fsp->fsp_name->st.vfs_private & GPFS_WINATTR_OFFLINE) != 0)) {
1972 fsp->fsp_name->st.vfs_private &= ~GPFS_WINATTR_OFFLINE;
1973 DEBUG(10, ("sending notify\n"));
1974 notify_fname(fsp->conn, NOTIFY_ACTION_MODIFIED,
1975 FILE_NOTIFY_CHANGE_ATTRIBUTES,
1976 fsp->fsp_name->base_name);
1977 }
1978
1979 return state->ret;
1980 }
1981
1982
1983 static struct vfs_fn_pointers vfs_gpfs_fns = {
1984 .connect_fn = vfs_gpfs_connect,
1985 .disk_free_fn = vfs_gpfs_disk_free,
1986 .fs_capabilities_fn = vfs_gpfs_capabilities,
1987 .kernel_flock_fn = vfs_gpfs_kernel_flock,
1988 .linux_setlease_fn = vfs_gpfs_setlease,
1989 .get_real_filename_fn = vfs_gpfs_get_real_filename,
1990 .fget_nt_acl_fn = gpfsacl_fget_nt_acl,
1991 .get_nt_acl_fn = gpfsacl_get_nt_acl,
1992 .fset_nt_acl_fn = gpfsacl_fset_nt_acl,
1993 .sys_acl_get_file_fn = gpfsacl_sys_acl_get_file,
1994 .sys_acl_get_fd_fn = gpfsacl_sys_acl_get_fd,
1995 .sys_acl_blob_get_file_fn = gpfsacl_sys_acl_blob_get_file,
1996 .sys_acl_blob_get_fd_fn = gpfsacl_sys_acl_blob_get_fd,
1997 .sys_acl_set_file_fn = gpfsacl_sys_acl_set_file,
1998 .sys_acl_set_fd_fn = gpfsacl_sys_acl_set_fd,
1999 .sys_acl_delete_def_file_fn = gpfsacl_sys_acl_delete_def_file,
2000 .chmod_fn = vfs_gpfs_chmod,
2001 .fchmod_fn = vfs_gpfs_fchmod,
2002 .close_fn = vfs_gpfs_close,
2003 .setxattr_fn = gpfs_set_xattr,
2004 .getxattr_fn = gpfs_get_xattr,
2005 .stat_fn = vfs_gpfs_stat,
2006 .fstat_fn = vfs_gpfs_fstat,
2007 .lstat_fn = vfs_gpfs_lstat,
2008 .ntimes_fn = vfs_gpfs_ntimes,
2009 .is_offline_fn = vfs_gpfs_is_offline,
2010 .aio_force_fn = vfs_gpfs_aio_force,
2011 .sendfile_fn = vfs_gpfs_sendfile,
2012 .fallocate_fn = vfs_gpfs_fallocate,
2013 .open_fn = vfs_gpfs_open,
2014 .pread_fn = vfs_gpfs_pread,
2015 .pread_send_fn = vfs_gpfs_pread_send,
2016 .pread_recv_fn = vfs_gpfs_pread_recv,
2017 .pwrite_fn = vfs_gpfs_pwrite,
2018 .pwrite_send_fn = vfs_gpfs_pwrite_send,
2019 .pwrite_recv_fn = vfs_gpfs_pwrite_recv,
2020 .ftruncate_fn = vfs_gpfs_ftruncate
2021 };
2022
2023 NTSTATUS vfs_gpfs_init(void);
2024 NTSTATUS vfs_gpfs_init(void)
2025 {
2026 init_gpfs();
2027
2028 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "gpfs",
2029 &vfs_gpfs_fns);
2030 }