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