source3/modules/vfs_fruit.c

   1 /*
   2  * OS X and Netatalk interoperability VFS module for Samba-3.x
   3  *
   4  * Copyright (C) Ralph Boehme, 2013, 2014
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "includes.h"
  21 #include "MacExtensions.h"
  22 #include "smbd/smbd.h"
  23 #include "system/filesys.h"
  24 #include "lib/util/time.h"
  25 #include "system/shmem.h"
  26 #include "locking/proto.h"
  27 #include "smbd/globals.h"
  28 #include "messages.h"
  29 #include "libcli/security/security.h"
  30 #include "../libcli/smb/smb2_create_ctx.h"
  31 #include "lib/util/tevent_ntstatus.h"
  32 #include "lib/util/tevent_unix.h"
  33 #include "lib/util/util_file.h"
  34 #include "offload_token.h"
  35 #include "string_replace.h"
  36 #include "hash_inode.h"
  37 #include "lib/adouble.h"
  38 #include "lib/util_macstreams.h"
  39 #include "source3/smbd/dir.h"
  40
  41 /*
  42  * Enhanced OS X and Netatalk compatibility
  43  * ========================================
  44  *
  45  * This modules takes advantage of vfs_streams_xattr and
  46  * vfs_catia. VFS modules vfs_fruit and vfs_streams_xattr must be
  47  * loaded in the correct order:
  48  *
  49  *   vfs modules = catia fruit streams_xattr
  50  *
  51  * The module intercepts the OS X special streams "AFP_AfpInfo" and
  52  * "AFP_Resource" and handles them in a special way. All other named
  53  * streams are deferred to vfs_streams_xattr.
  54  *
  55  * The OS X client maps all NTFS illegal characters to the Unicode
  56  * private range. This module optionally stores the characters using
  57  * their native ASCII encoding using vfs_catia. If you're not enabling
  58  * this feature, you can skip catia from vfs modules.
  59  *
  60  * Finally, open modes are optionally checked against Netatalk AFP
  61  * share modes.
  62  *
  63  * The "AFP_AfpInfo" named stream is a binary blob containing OS X
  64  * extended metadata for files and directories. This module optionally
  65  * reads and stores this metadata in a way compatible with Netatalk 3
  66  * which stores the metadata in an EA "org.netatalk.metadata". Cf
  67  * source3/include/MacExtensions.h for a description of the binary
  68  * blobs content.
  69  *
  70  * The "AFP_Resource" named stream may be arbitrarily large, thus it
  71  * can't be stored in an xattr on most filesystem. ZFS on Solaris is
  72  * the only available filesystem where xattrs can be of any size and
  73  * the OS supports using the file APIs for xattrs.
  74  *
  75  * The AFP_Resource stream is stored in an AppleDouble file prepending
  76  * "._" to the filename. On Solaris with ZFS the stream is optionally
  77  * stored in an EA "org.netatalk.resource".
  78  *
  79  *
  80  * Extended Attributes
  81  * ===================
  82  *
  83  * The OS X SMB client sends xattrs as ADS too. For xattr interop with
  84  * other protocols you may want to adjust the xattr names the VFS
  85  * module vfs_streams_xattr uses for storing ADS's. This defaults to
  86  * user.DosStream.ADS_NAME:$DATA and can be changed by specifying
  87  * these module parameters:
  88  *
  89  *   streams_xattr:prefix = user.
  90  *   streams_xattr:store_stream_type = false
  91  *
  92  *
  93  * TODO
  94  * ====
  95  *
  96  * - log diagnostic if any needed VFS module is not loaded
  97  *   (eg with lp_vfs_objects())
  98  * - add tests
  99  */
 100
 101 static int vfs_fruit_debug_level = DBGC_VFS;
 102
 103 static struct global_fruit_config {
 104         bool nego_aapl; /* client negotiated AAPL */
 105
 106 } global_fruit_config;
 107
 108 #undef DBGC_CLASS
 109 #define DBGC_CLASS vfs_fruit_debug_level
 110
 111 #define FRUIT_PARAM_TYPE_NAME "fruit"
 112
 113 enum apple_fork {APPLE_FORK_DATA, APPLE_FORK_RSRC};
 114
 115 enum fruit_rsrc {FRUIT_RSRC_STREAM, FRUIT_RSRC_ADFILE, FRUIT_RSRC_XATTR};
 116 enum fruit_meta {FRUIT_META_STREAM, FRUIT_META_NETATALK};
 117 enum fruit_locking {FRUIT_LOCKING_NETATALK, FRUIT_LOCKING_NONE};
 118 enum fruit_encoding {FRUIT_ENC_NATIVE, FRUIT_ENC_PRIVATE};
 119
 120 struct fruit_config_data {
 121         enum fruit_rsrc rsrc;
 122         enum fruit_meta meta;
 123         enum fruit_locking locking;
 124         enum fruit_encoding encoding;
 125         bool use_aapl;          /* config from smb.conf */
 126         bool use_copyfile;
 127         bool readdir_attr_enabled;
 128         bool unix_info_enabled;
 129         bool copyfile_enabled;
 130         bool veto_appledouble;
 131         bool posix_rename;
 132         bool aapl_zero_file_id;
 133         const char *model;
 134         bool time_machine;
 135         off_t time_machine_max_size;
 136         bool convert_adouble;
 137         bool wipe_intentionally_left_blank_rfork;
 138         bool delete_empty_adfiles;
 139         bool validate_afpinfo;
 140
 141         /*
 142          * Additional options, all enabled by default,
 143          * possibly useful for analyzing performance. The associated
 144          * operations with each of them may be expensive, so having
 145          * the chance to disable them individually gives a chance
 146          * tweaking the setup for the particular usecase.
 147          */
 148         bool readdir_attr_rsize;
 149         bool readdir_attr_finder_info;
 150         bool readdir_attr_max_access;
 151         /* Recursion guard. Will go away when we have STATX. */
 152         bool in_openat_pathref_fsp;
 153 };
 154
 155 static const struct enum_list fruit_rsrc[] = {
 156         {FRUIT_RSRC_STREAM, "stream"}, /* pass on to vfs_streams_xattr */
 157         {FRUIT_RSRC_ADFILE, "file"}, /* ._ AppleDouble file */
 158         {FRUIT_RSRC_XATTR, "xattr"}, /* Netatalk compatible xattr (ZFS only) */
 159         { -1, NULL}
 160 };
 161
 162 static const struct enum_list fruit_meta[] = {
 163         {FRUIT_META_STREAM, "stream"}, /* pass on to vfs_streams_xattr */
 164         {FRUIT_META_NETATALK, "netatalk"}, /* Netatalk compatible xattr */
 165         { -1, NULL}
 166 };
 167
 168 static const struct enum_list fruit_locking[] = {
 169         {FRUIT_LOCKING_NETATALK, "netatalk"}, /* synchronize locks with Netatalk */
 170         {FRUIT_LOCKING_NONE, "none"},
 171         { -1, NULL}
 172 };
 173
 174 static const struct enum_list fruit_encoding[] = {
 175         {FRUIT_ENC_NATIVE, "native"}, /* map unicode private chars to ASCII */
 176         {FRUIT_ENC_PRIVATE, "private"}, /* keep unicode private chars */
 177         { -1, NULL}
 178 };
 179
 180 struct fio {
 181         vfs_handle_struct *handle;
 182         files_struct *fsp; /* backlink to itself */
 183
 184         /* tcon config handle */
 185         struct fruit_config_data *config;
 186
 187         /* Backend fsp for AppleDouble file, can be NULL */
 188         files_struct *ad_fsp;
 189         /* link from adouble_open_from_base_fsp() to fio */
 190         struct fio *real_fio;
 191
 192         /* Denote stream type, meta or rsrc */
 193         adouble_type_t type;
 194
 195         /*
 196          * AFP_AfpInfo stream created, but not written yet, thus still a fake
 197          * pipe fd. This is set to true in fruit_open_meta if there was no
 198          * existing stream but the caller requested O_CREAT. It is later set to
 199          * false when we get a write on the stream that then does open and
 200          * create the stream.
 201          */
 202         bool fake_fd;
 203         int flags;
 204         int mode;
 205 };
 206
 207 /*****************************************************************************
 208  * Helper functions
 209  *****************************************************************************/
 210
 211 static struct adouble *ad_get_meta_fsp(TALLOC_CTX *ctx,
 212                                        vfs_handle_struct *handle,
 213                                        const struct smb_filename *smb_fname)
 214 {
 215         NTSTATUS status;
 216         struct adouble *ad = NULL;
 217         struct smb_filename *smb_fname_cp = NULL;
 218         struct fruit_config_data *config = NULL;
 219
 220         if (smb_fname->fsp != NULL) {
 221                 return ad_get(ctx, handle, smb_fname, ADOUBLE_META);
 222         }
 223
 224         SMB_VFS_HANDLE_GET_DATA(handle,
 225                                 config,
 226                                 struct fruit_config_data,
 227                                 return NULL);
 228
 229         if (config->in_openat_pathref_fsp) {
 230                 return NULL;
 231         }
 232
 233         smb_fname_cp = cp_smb_filename(ctx,
 234                                        smb_fname);
 235         if (smb_fname_cp == NULL) {
 236                 return NULL;
 237         }
 238         TALLOC_FREE(smb_fname_cp->stream_name);
 239         config->in_openat_pathref_fsp = true;
 240         status = openat_pathref_fsp(handle->conn->cwd_fsp,
 241                                     smb_fname_cp);
 242         config->in_openat_pathref_fsp = false;
 243         if (!NT_STATUS_IS_OK(status)) {
 244                 TALLOC_FREE(smb_fname_cp);
 245                 return NULL;
 246         }
 247
 248         ad = ad_get(ctx, handle, smb_fname_cp, ADOUBLE_META);
 249         TALLOC_FREE(smb_fname_cp);
 250         return ad;
 251 }
 252
 253 static struct fio *fruit_get_complete_fio(vfs_handle_struct *handle,
 254                                           files_struct *fsp)
 255 {
 256         struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
 257
 258         if (fio == NULL) {
 259                 return NULL;
 260         }
 261
 262         if (fio->real_fio != NULL) {
 263                 /*
 264                  * This is an fsp from adouble_open_from_base_fsp()
 265                  * we should just pass this to the next
 266                  * module.
 267                  */
 268                 return NULL;
 269         }
 270
 271         return fio;
 272 }
 273
 274 /**
 275  * Initialize config struct from our smb.conf config parameters
 276  **/
 277 static int init_fruit_config(vfs_handle_struct *handle)
 278 {
 279         struct fruit_config_data *config;
 280         int enumval = -1;
 281         const char *tm_size_str = NULL;
 282
 283         config = talloc_zero(handle->conn, struct fruit_config_data);
 284         if (!config) {
 285                 DEBUG(1, ("talloc_zero() failed\n"));
 286                 errno = ENOMEM;
 287                 return -1;
 288         }
 289
 290         enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
 291                                "resource", fruit_rsrc, FRUIT_RSRC_ADFILE);
 292         if (enumval == -1) {
 293                 DEBUG(1, ("value for %s: resource type unknown\n",
 294                           FRUIT_PARAM_TYPE_NAME));
 295                 return -1;
 296         }
 297         config->rsrc = (enum fruit_rsrc)enumval;
 298
 299         enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
 300                                "metadata", fruit_meta, FRUIT_META_NETATALK);
 301         if (enumval == -1) {
 302                 DEBUG(1, ("value for %s: metadata type unknown\n",
 303                           FRUIT_PARAM_TYPE_NAME));
 304                 return -1;
 305         }
 306         config->meta = (enum fruit_meta)enumval;
 307
 308         enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
 309                                "locking", fruit_locking, FRUIT_LOCKING_NONE);
 310         if (enumval == -1) {
 311                 DEBUG(1, ("value for %s: locking type unknown\n",
 312                           FRUIT_PARAM_TYPE_NAME));
 313                 return -1;
 314         }
 315         config->locking = (enum fruit_locking)enumval;
 316
 317         enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
 318                                "encoding", fruit_encoding, FRUIT_ENC_PRIVATE);
 319         if (enumval == -1) {
 320                 DEBUG(1, ("value for %s: encoding type unknown\n",
 321                           FRUIT_PARAM_TYPE_NAME));
 322                 return -1;
 323         }
 324         config->encoding = (enum fruit_encoding)enumval;
 325
 326         if (config->rsrc == FRUIT_RSRC_ADFILE) {
 327                 config->veto_appledouble = lp_parm_bool(SNUM(handle->conn),
 328                                                         FRUIT_PARAM_TYPE_NAME,
 329                                                         "veto_appledouble",
 330                                                         true);
 331         }
 332
 333         config->use_aapl = lp_parm_bool(
 334                 -1, FRUIT_PARAM_TYPE_NAME, "aapl", true);
 335
 336         config->time_machine = lp_parm_bool(
 337                 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME, "time machine", false);
 338
 339         config->unix_info_enabled = lp_parm_bool(
 340                 -1, FRUIT_PARAM_TYPE_NAME, "nfs_aces", true);
 341
 342         config->use_copyfile = lp_parm_bool(-1, FRUIT_PARAM_TYPE_NAME,
 343                                            "copyfile", false);
 344
 345         config->posix_rename = lp_parm_bool(
 346                 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME, "posix_rename", true);
 347
 348         config->aapl_zero_file_id =
 349             lp_parm_bool(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
 350                          "zero_file_id", true);
 351
 352         config->readdir_attr_rsize = lp_parm_bool(
 353                 SNUM(handle->conn), "readdir_attr", "aapl_rsize", true);
 354
 355         config->readdir_attr_finder_info = lp_parm_bool(
 356                 SNUM(handle->conn), "readdir_attr", "aapl_finder_info", true);
 357
 358         config->readdir_attr_max_access = lp_parm_bool(
 359                 SNUM(handle->conn), "readdir_attr", "aapl_max_access", true);
 360
 361         config->model = lp_parm_const_string(
 362                 -1, FRUIT_PARAM_TYPE_NAME, "model", "MacSamba");
 363
 364         tm_size_str = lp_parm_const_string(
 365                 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
 366                 "time machine max size", NULL);
 367         if (tm_size_str != NULL) {
 368                 config->time_machine_max_size = conv_str_size(tm_size_str);
 369         }
 370
 371         config->convert_adouble = lp_parm_bool(
 372                 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
 373                 "convert_adouble", true);
 374
 375         config->wipe_intentionally_left_blank_rfork = lp_parm_bool(
 376                 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
 377                 "wipe_intentionally_left_blank_rfork", false);
 378
 379         config->delete_empty_adfiles = lp_parm_bool(
 380                 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
 381                 "delete_empty_adfiles", false);
 382
 383         config->validate_afpinfo = lp_parm_bool(
 384                 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
 385                 "validate_afpinfo", true);
 386
 387         SMB_VFS_HANDLE_SET_DATA(handle, config,
 388                                 NULL, struct fruit_config_data,
 389                                 return -1);
 390
 391         return 0;
 392 }
 393
 394 static bool add_fruit_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
 395                              struct stream_struct **streams,
 396                              const char *name, off_t size,
 397                              off_t alloc_size)
 398 {
 399         struct stream_struct *tmp;
 400
 401         tmp = talloc_realloc(mem_ctx, *streams, struct stream_struct,
 402                              (*num_streams)+1);
 403         if (tmp == NULL) {
 404                 return false;
 405         }
 406
 407         tmp[*num_streams].name = talloc_asprintf(tmp, "%s:$DATA", name);
 408         if (tmp[*num_streams].name == NULL) {
 409                 return false;
 410         }
 411
 412         tmp[*num_streams].size = size;
 413         tmp[*num_streams].alloc_size = alloc_size;
 414
 415         *streams = tmp;
 416         *num_streams += 1;
 417         return true;
 418 }
 419
 420 static bool filter_empty_rsrc_stream(unsigned int *num_streams,
 421                                      struct stream_struct **streams)
 422 {
 423         struct stream_struct *tmp = *streams;
 424         unsigned int i;
 425
 426         if (*num_streams == 0) {
 427                 return true;
 428         }
 429
 430         for (i = 0; i < *num_streams; i++) {
 431                 if (strequal_m(tmp[i].name, AFPRESOURCE_STREAM)) {
 432                         break;
 433                 }
 434         }
 435
 436         if (i == *num_streams) {
 437                 return true;
 438         }
 439
 440         if (tmp[i].size > 0) {
 441                 return true;
 442         }
 443
 444         TALLOC_FREE(tmp[i].name);
 445         ARRAY_DEL_ELEMENT(tmp, i, *num_streams);
 446         *num_streams -= 1;
 447         return true;
 448 }
 449
 450 static bool del_fruit_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
 451                              struct stream_struct **streams,
 452                              const char *name)
 453 {
 454         struct stream_struct *tmp = *streams;
 455         unsigned int i;
 456
 457         if (*num_streams == 0) {
 458                 return true;
 459         }
 460
 461         for (i = 0; i < *num_streams; i++) {
 462                 if (strequal_m(tmp[i].name, name)) {
 463                         break;
 464                 }
 465         }
 466
 467         if (i == *num_streams) {
 468                 return true;
 469         }
 470
 471         TALLOC_FREE(tmp[i].name);
 472         ARRAY_DEL_ELEMENT(tmp, i, *num_streams);
 473         *num_streams -= 1;
 474         return true;
 475 }
 476
 477 static bool ad_empty_finderinfo(const struct adouble *ad)
 478 {
 479         int cmp;
 480         char emptybuf[ADEDLEN_FINDERI] = {0};
 481         char *fi = NULL;
 482
 483         fi = ad_get_entry(ad, ADEID_FINDERI);
 484         if (fi == NULL) {
 485                 DBG_ERR("Missing FinderInfo in struct adouble [%p]\n", ad);
 486                 return false;
 487         }
 488
 489         cmp = memcmp(emptybuf, fi, ADEDLEN_FINDERI);
 490         return (cmp == 0);
 491 }
 492
 493 static bool ai_empty_finderinfo(const AfpInfo *ai)
 494 {
 495         int cmp;
 496         char emptybuf[ADEDLEN_FINDERI] = {0};
 497
 498         cmp = memcmp(emptybuf, &ai->afpi_FinderInfo[0], ADEDLEN_FINDERI);
 499         return (cmp == 0);
 500 }
 501
 502 /**
 503  * Update btime with btime from Netatalk
 504  **/
 505 static void update_btime(vfs_handle_struct *handle,
 506                          struct smb_filename *smb_fname)
 507 {
 508         uint32_t t;
 509         struct timespec creation_time = {0};
 510         struct adouble *ad;
 511         struct fruit_config_data *config = NULL;
 512
 513         SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
 514                                 return);
 515
 516         switch (config->meta) {
 517         case FRUIT_META_STREAM:
 518                 return;
 519         case FRUIT_META_NETATALK:
 520                 /* Handled below */
 521                 break;
 522         default:
 523                 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
 524                 return;
 525         }
 526
 527         ad = ad_get_meta_fsp(talloc_tos(), handle, smb_fname);
 528         if (ad == NULL) {
 529                 return;
 530         }
 531         if (ad_getdate(ad, AD_DATE_UNIX | AD_DATE_CREATE, &t) != 0) {
 532                 TALLOC_FREE(ad);
 533                 return;
 534         }
 535         TALLOC_FREE(ad);
 536
 537         creation_time.tv_sec = convert_uint32_t_to_time_t(t);
 538         update_stat_ex_create_time(&smb_fname->st, creation_time);
 539
 540         return;
 541 }
 542
 543 /**
 544  * Map an access mask to a Netatalk single byte byte range lock
 545  **/
 546 static off_t access_to_netatalk_brl(enum apple_fork fork_type,
 547                                     uint32_t access_mask)
 548 {
 549         off_t offset;
 550
 551         switch (access_mask) {
 552         case FILE_READ_DATA:
 553                 offset = AD_FILELOCK_OPEN_RD;
 554                 break;
 555
 556         case FILE_WRITE_DATA:
 557         case FILE_APPEND_DATA:
 558                 offset = AD_FILELOCK_OPEN_WR;
 559                 break;
 560
 561         default:
 562                 offset = AD_FILELOCK_OPEN_NONE;
 563                 break;
 564         }
 565
 566         if (fork_type == APPLE_FORK_RSRC) {
 567                 if (offset == AD_FILELOCK_OPEN_NONE) {
 568                         offset = AD_FILELOCK_RSRC_OPEN_NONE;
 569                 } else {
 570                         offset += 2;
 571                 }
 572         }
 573
 574         return offset;
 575 }
 576
 577 /**
 578  * Map a deny mode to a Netatalk brl
 579  **/
 580 static off_t denymode_to_netatalk_brl(enum apple_fork fork_type,
 581                                       uint32_t deny_mode)
 582 {
 583         off_t offset = 0;
 584
 585         switch (deny_mode) {
 586         case DENY_READ:
 587                 offset = AD_FILELOCK_DENY_RD;
 588                 break;
 589
 590         case DENY_WRITE:
 591                 offset = AD_FILELOCK_DENY_WR;
 592                 break;
 593
 594         default:
 595                 smb_panic("denymode_to_netatalk_brl: bad deny mode\n");
 596         }
 597
 598         if (fork_type == APPLE_FORK_RSRC) {
 599                 offset += 2;
 600         }
 601
 602         return offset;
 603 }
 604
 605 /**
 606  * Call fcntl() with an exclusive F_GETLK request in order to
 607  * determine if there's an existing shared lock
 608  *
 609  * @return true if the requested lock was found or any error occurred
 610  *         false if the lock was not found
 611  **/
 612 static bool test_netatalk_lock(files_struct *fsp, off_t in_offset)
 613 {
 614         bool result;
 615         off_t offset = in_offset;
 616         off_t len = 1;
 617         int type = F_WRLCK;
 618         pid_t pid = 0;
 619
 620         result = SMB_VFS_GETLOCK(fsp, &offset, &len, &type, &pid);
 621         if (result == false) {
 622                 return true;
 623         }
 624
 625         if (type != F_UNLCK) {
 626                 return true;
 627         }
 628
 629         return false;
 630 }
 631
 632 static NTSTATUS fruit_check_access(vfs_handle_struct *handle,
 633                                    files_struct *fsp,
 634                                    uint32_t access_mask,
 635                                    uint32_t share_mode)
 636 {
 637         NTSTATUS status = NT_STATUS_OK;
 638         off_t off;
 639         bool share_for_read = (share_mode & FILE_SHARE_READ);
 640         bool share_for_write = (share_mode & FILE_SHARE_WRITE);
 641         bool netatalk_already_open_for_reading = false;
 642         bool netatalk_already_open_for_writing = false;
 643         bool netatalk_already_open_with_deny_read = false;
 644         bool netatalk_already_open_with_deny_write = false;
 645         struct GUID req_guid = GUID_random();
 646
 647         /* FIXME: hardcoded data fork, add resource fork */
 648         enum apple_fork fork_type = APPLE_FORK_DATA;
 649
 650         DBG_DEBUG("fruit_check_access: %s, am: %s/%s, sm: 0x%x\n",
 651                   fsp_str_dbg(fsp),
 652                   access_mask & FILE_READ_DATA ? "READ" :"-",
 653                   access_mask & FILE_WRITE_DATA ? "WRITE" : "-",
 654                   share_mode);
 655
 656         if (fsp_get_io_fd(fsp) == -1) {
 657                 return NT_STATUS_OK;
 658         }
 659
 660         /* Read NetATalk opens and deny modes on the file. */
 661         netatalk_already_open_for_reading = test_netatalk_lock(fsp,
 662                                 access_to_netatalk_brl(fork_type,
 663                                         FILE_READ_DATA));
 664
 665         netatalk_already_open_with_deny_read = test_netatalk_lock(fsp,
 666                                 denymode_to_netatalk_brl(fork_type,
 667                                         DENY_READ));
 668
 669         netatalk_already_open_for_writing = test_netatalk_lock(fsp,
 670                                 access_to_netatalk_brl(fork_type,
 671                                         FILE_WRITE_DATA));
 672
 673         netatalk_already_open_with_deny_write = test_netatalk_lock(fsp,
 674                                 denymode_to_netatalk_brl(fork_type,
 675                                         DENY_WRITE));
 676
 677         /* If there are any conflicts - sharing violation. */
 678         if ((access_mask & FILE_READ_DATA) &&
 679                         netatalk_already_open_with_deny_read) {
 680                 return NT_STATUS_SHARING_VIOLATION;
 681         }
 682
 683         if (!share_for_read &&
 684                         netatalk_already_open_for_reading) {
 685                 return NT_STATUS_SHARING_VIOLATION;
 686         }
 687
 688         if ((access_mask & FILE_WRITE_DATA) &&
 689                         netatalk_already_open_with_deny_write) {
 690                 return NT_STATUS_SHARING_VIOLATION;
 691         }
 692
 693         if (!share_for_write &&
 694                         netatalk_already_open_for_writing) {
 695                 return NT_STATUS_SHARING_VIOLATION;
 696         }
 697
 698         if (!(access_mask & FILE_READ_DATA)) {
 699                 /*
 700                  * Nothing we can do here, we need read access
 701                  * to set locks.
 702                  */
 703                 return NT_STATUS_OK;
 704         }
 705
 706         /* Set NetAtalk locks matching our access */
 707         if (access_mask & FILE_READ_DATA) {
 708                 off = access_to_netatalk_brl(fork_type, FILE_READ_DATA);
 709                 req_guid.time_hi_and_version = __LINE__;
 710                 status = do_lock(
 711                         fsp,
 712                         talloc_tos(),
 713                         &req_guid,
 714                         fsp->op->global->open_persistent_id,
 715                         1,
 716                         off,
 717                         READ_LOCK,
 718                         POSIX_LOCK,
 719                         NULL,
 720                         NULL);
 721
 722                 if (!NT_STATUS_IS_OK(status))  {
 723                         return status;
 724                 }
 725         }
 726
 727         if (!share_for_read) {
 728                 off = denymode_to_netatalk_brl(fork_type, DENY_READ);
 729                 req_guid.time_hi_and_version = __LINE__;
 730                 status = do_lock(
 731                         fsp,
 732                         talloc_tos(),
 733                         &req_guid,
 734                         fsp->op->global->open_persistent_id,
 735                         1,
 736                         off,
 737                         READ_LOCK,
 738                         POSIX_LOCK,
 739                         NULL,
 740                         NULL);
 741
 742                 if (!NT_STATUS_IS_OK(status)) {
 743                         return status;
 744                 }
 745         }
 746
 747         if (access_mask & FILE_WRITE_DATA) {
 748                 off = access_to_netatalk_brl(fork_type, FILE_WRITE_DATA);
 749                 req_guid.time_hi_and_version = __LINE__;
 750                 status = do_lock(
 751                         fsp,
 752                         talloc_tos(),
 753                         &req_guid,
 754                         fsp->op->global->open_persistent_id,
 755                         1,
 756                         off,
 757                         READ_LOCK,
 758                         POSIX_LOCK,
 759                         NULL,
 760                         NULL);
 761
 762                 if (!NT_STATUS_IS_OK(status)) {
 763                         return status;
 764                 }
 765         }
 766
 767         if (!share_for_write) {
 768                 off = denymode_to_netatalk_brl(fork_type, DENY_WRITE);
 769                 req_guid.time_hi_and_version = __LINE__;
 770                 status = do_lock(
 771                         fsp,
 772                         talloc_tos(),
 773                         &req_guid,
 774                         fsp->op->global->open_persistent_id,
 775                         1,
 776                         off,
 777                         READ_LOCK,
 778                         POSIX_LOCK,
 779                         NULL,
 780                         NULL);
 781
 782                 if (!NT_STATUS_IS_OK(status)) {
 783                         return status;
 784                 }
 785         }
 786
 787         return NT_STATUS_OK;
 788 }
 789
 790 static NTSTATUS check_aapl(vfs_handle_struct *handle,
 791                            struct smb_request *req,
 792                            const struct smb2_create_blobs *in_context_blobs,
 793                            struct smb2_create_blobs *out_context_blobs)
 794 {
 795         struct fruit_config_data *config;
 796         NTSTATUS status;
 797         struct smb2_create_blob *aapl = NULL;
 798         uint32_t cmd;
 799         bool ok;
 800         uint8_t p[16];
 801         DATA_BLOB blob = data_blob_talloc(req, NULL, 0);
 802         uint64_t req_bitmap, client_caps;
 803         uint64_t server_caps = SMB2_CRTCTX_AAPL_UNIX_BASED;
 804         smb_ucs2_t *model;
 805         size_t modellen;
 806
 807         SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
 808                                 return NT_STATUS_UNSUCCESSFUL);
 809
 810         if (!config->use_aapl
 811             || in_context_blobs == NULL
 812             || out_context_blobs == NULL) {
 813                 return NT_STATUS_OK;
 814         }
 815
 816         aapl = smb2_create_blob_find(in_context_blobs,
 817                                      SMB2_CREATE_TAG_AAPL);
 818         if (aapl == NULL) {
 819                 return NT_STATUS_OK;
 820         }
 821
 822         if (aapl->data.length != 24) {
 823                 DEBUG(1, ("unexpected AAPL ctxt length: %ju\n",
 824                           (uintmax_t)aapl->data.length));
 825                 return NT_STATUS_INVALID_PARAMETER;
 826         }
 827
 828         cmd = IVAL(aapl->data.data, 0);
 829         if (cmd != SMB2_CRTCTX_AAPL_SERVER_QUERY) {
 830                 DEBUG(1, ("unsupported AAPL cmd: %d\n", cmd));
 831                 return NT_STATUS_INVALID_PARAMETER;
 832         }
 833
 834         req_bitmap = BVAL(aapl->data.data, 8);
 835         client_caps = BVAL(aapl->data.data, 16);
 836
 837         SIVAL(p, 0, SMB2_CRTCTX_AAPL_SERVER_QUERY);
 838         SIVAL(p, 4, 0);
 839         SBVAL(p, 8, req_bitmap);
 840         ok = data_blob_append(req, &blob, p, 16);
 841         if (!ok) {
 842                 return NT_STATUS_UNSUCCESSFUL;
 843         }
 844
 845         if (req_bitmap & SMB2_CRTCTX_AAPL_SERVER_CAPS) {
 846                 if ((client_caps & SMB2_CRTCTX_AAPL_SUPPORTS_READ_DIR_ATTR) &&
 847                     (handle->conn->fs_capabilities & FILE_NAMED_STREAMS)) {
 848                         server_caps |= SMB2_CRTCTX_AAPL_SUPPORTS_READ_DIR_ATTR;
 849                         config->readdir_attr_enabled = true;
 850                 }
 851
 852                 if (config->use_copyfile) {
 853                         server_caps |= SMB2_CRTCTX_AAPL_SUPPORTS_OSX_COPYFILE;
 854                         config->copyfile_enabled = true;
 855                 }
 856
 857                 /*
 858                  * The client doesn't set the flag, so we can't check
 859                  * for it and just set it unconditionally
 860                  */
 861                 if (config->unix_info_enabled) {
 862                         server_caps |= SMB2_CRTCTX_AAPL_SUPPORTS_NFS_ACE;
 863                 }
 864
 865                 SBVAL(p, 0, server_caps);
 866                 ok = data_blob_append(req, &blob, p, 8);
 867                 if (!ok) {
 868                         return NT_STATUS_UNSUCCESSFUL;
 869                 }
 870         }
 871
 872         if (req_bitmap & SMB2_CRTCTX_AAPL_VOLUME_CAPS) {
 873                 int val = lp_case_sensitive(SNUM(handle->conn));
 874                 uint64_t caps = 0;
 875
 876                 switch (val) {
 877                 case Auto:
 878                         break;
 879
 880                 case True:
 881                         caps |= SMB2_CRTCTX_AAPL_CASE_SENSITIVE;
 882                         break;
 883
 884                 default:
 885                         break;
 886                 }
 887
 888                 if (config->time_machine) {
 889                         caps |= SMB2_CRTCTX_AAPL_FULL_SYNC;
 890                 }
 891
 892                 SBVAL(p, 0, caps);
 893
 894                 ok = data_blob_append(req, &blob, p, 8);
 895                 if (!ok) {
 896                         return NT_STATUS_UNSUCCESSFUL;
 897                 }
 898         }
 899
 900         if (req_bitmap & SMB2_CRTCTX_AAPL_MODEL_INFO) {
 901                 ok = convert_string_talloc(req,
 902                                            CH_UNIX, CH_UTF16LE,
 903                                            config->model, strlen(config->model),
 904                                            &model, &modellen);
 905                 if (!ok) {
 906                         return NT_STATUS_UNSUCCESSFUL;
 907                 }
 908
 909                 SIVAL(p, 0, 0);
 910                 SIVAL(p + 4, 0, modellen);
 911                 ok = data_blob_append(req, &blob, p, 8);
 912                 if (!ok) {
 913                         talloc_free(model);
 914                         return NT_STATUS_UNSUCCESSFUL;
 915                 }
 916
 917                 ok = data_blob_append(req, &blob, model, modellen);
 918                 talloc_free(model);
 919                 if (!ok) {
 920                         return NT_STATUS_UNSUCCESSFUL;
 921                 }
 922         }
 923
 924         status = smb2_create_blob_add(out_context_blobs,
 925                                       out_context_blobs,
 926                                       SMB2_CREATE_TAG_AAPL,
 927                                       blob);
 928         if (NT_STATUS_IS_OK(status)) {
 929                 global_fruit_config.nego_aapl = true;
 930         }
 931
 932         return status;
 933 }
 934
 935 static bool readdir_attr_meta_finderi_stream(
 936         struct vfs_handle_struct *handle,
 937         const struct smb_filename *smb_fname,
 938         AfpInfo *ai)
 939 {
 940         struct smb_filename *stream_name = NULL;
 941         files_struct *fsp = NULL;
 942         ssize_t nread;
 943         NTSTATUS status;
 944         bool ok;
 945         uint8_t buf[AFP_INFO_SIZE];
 946
 947         status = synthetic_pathref(talloc_tos(),
 948                                    handle->conn->cwd_fsp,
 949                                    smb_fname->base_name,
 950                                    AFPINFO_STREAM_NAME,
 951                                    NULL,
 952                                    smb_fname->twrp,
 953                                    smb_fname->flags,
 954                                    &stream_name);
 955         if (!NT_STATUS_IS_OK(status)) {
 956                 return false;
 957         }
 958
 959         status = SMB_VFS_CREATE_FILE(
 960                 handle->conn,                           /* conn */
 961                 NULL,                                   /* req */
 962                 NULL,                                   /* dirfsp */
 963                 stream_name,                            /* fname */
 964                 FILE_READ_DATA,                         /* access_mask */
 965                 (FILE_SHARE_READ | FILE_SHARE_WRITE |   /* share_access */
 966                         FILE_SHARE_DELETE),
 967                 FILE_OPEN,                              /* create_disposition*/
 968                 0,                                      /* create_options */
 969                 0,                                      /* file_attributes */
 970                 INTERNAL_OPEN_ONLY,                     /* oplock_request */
 971                 NULL,                                   /* lease */
 972                 0,                                      /* allocation_size */
 973                 0,                                      /* private_flags */
 974                 NULL,                                   /* sd */
 975                 NULL,                                   /* ea_list */
 976                 &fsp,                                   /* result */
 977                 NULL,                                   /* pinfo */
 978                 NULL, NULL);                            /* create context */
 979
 980         TALLOC_FREE(stream_name);
 981
 982         if (!NT_STATUS_IS_OK(status)) {
 983                 return false;
 984         }
 985
 986         nread = SMB_VFS_PREAD(fsp, &buf[0], AFP_INFO_SIZE, 0);
 987         if (nread != AFP_INFO_SIZE) {
 988                 DBG_ERR("short read [%s] [%zd/%d]\n",
 989                         smb_fname_str_dbg(stream_name), nread, AFP_INFO_SIZE);
 990                 ok = false;
 991                 goto fail;
 992         }
 993
 994         memcpy(&ai->afpi_FinderInfo[0], &buf[AFP_OFF_FinderInfo],
 995                AFP_FinderSize);
 996
 997         ok = true;
 998
 999 fail:
1000         if (fsp != NULL) {
1001                 close_file_free(NULL, &fsp, NORMAL_CLOSE);
1002         }
1003
1004         return ok;
1005 }
1006
1007 static bool readdir_attr_meta_finderi_netatalk(
1008         struct vfs_handle_struct *handle,
1009         const struct smb_filename *smb_fname,
1010         AfpInfo *ai)
1011 {
1012         struct adouble *ad = NULL;
1013         char *p = NULL;
1014
1015         ad = ad_get_meta_fsp(talloc_tos(), handle, smb_fname);
1016         if (ad == NULL) {
1017                 return false;
1018         }
1019
1020         p = ad_get_entry(ad, ADEID_FINDERI);
1021         if (p == NULL) {
1022                 DBG_ERR("No ADEID_FINDERI for [%s]\n", smb_fname->base_name);
1023                 TALLOC_FREE(ad);
1024                 return false;
1025         }
1026
1027         memcpy(&ai->afpi_FinderInfo[0], p, AFP_FinderSize);
1028         TALLOC_FREE(ad);
1029         return true;
1030 }
1031
1032 static bool readdir_attr_meta_finderi(struct vfs_handle_struct *handle,
1033                                       const struct smb_filename *smb_fname,
1034                                       struct readdir_attr_data *attr_data)
1035 {
1036         struct fruit_config_data *config = NULL;
1037         uint32_t date_added;
1038         AfpInfo ai = {0};
1039         bool ok;
1040
1041         SMB_VFS_HANDLE_GET_DATA(handle, config,
1042                                 struct fruit_config_data,
1043                                 return false);
1044
1045         switch (config->meta) {
1046         case FRUIT_META_NETATALK:
1047                 ok = readdir_attr_meta_finderi_netatalk(
1048                         handle, smb_fname, &ai);
1049                 break;
1050
1051         case FRUIT_META_STREAM:
1052                 ok = readdir_attr_meta_finderi_stream(
1053                         handle, smb_fname, &ai);
1054                 break;
1055
1056         default:
1057                 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
1058                 return false;
1059         }
1060
1061         if (!ok) {
1062                 /* Don't bother with errors, it's likely ENOENT */
1063                 return true;
1064         }
1065
1066         if (S_ISREG(smb_fname->st.st_ex_mode)) {
1067                 /* finder_type */
1068                 memcpy(&attr_data->attr_data.aapl.finder_info[0],
1069                        &ai.afpi_FinderInfo[0], 4);
1070
1071                 /* finder_creator */
1072                 memcpy(&attr_data->attr_data.aapl.finder_info[0] + 4,
1073                        &ai.afpi_FinderInfo[4], 4);
1074         }
1075
1076         /* finder_flags */
1077         memcpy(&attr_data->attr_data.aapl.finder_info[0] + 8,
1078                &ai.afpi_FinderInfo[8], 2);
1079
1080         /* finder_ext_flags */
1081         memcpy(&attr_data->attr_data.aapl.finder_info[0] + 10,
1082                &ai.afpi_FinderInfo[24], 2);
1083
1084         /* creation date */
1085         date_added = convert_time_t_to_uint32_t(
1086                 smb_fname->st.st_ex_btime.tv_sec - AD_DATE_DELTA);
1087
1088         RSIVAL(&attr_data->attr_data.aapl.finder_info[0], 12, date_added);
1089
1090         return true;
1091 }
1092
1093 static uint64_t readdir_attr_rfork_size_adouble(
1094         struct vfs_handle_struct *handle,
1095         const struct smb_filename *smb_fname)
1096 {
1097         struct adouble *ad = NULL;
1098         uint64_t rfork_size;
1099
1100         ad = ad_get(talloc_tos(), handle, smb_fname,
1101                     ADOUBLE_RSRC);
1102         if (ad == NULL) {
1103                 return 0;
1104         }
1105
1106         rfork_size = ad_getentrylen(ad, ADEID_RFORK);
1107         TALLOC_FREE(ad);
1108
1109         return rfork_size;
1110 }
1111
1112 static uint64_t readdir_attr_rfork_size_stream(
1113         struct vfs_handle_struct *handle,
1114         const struct smb_filename *smb_fname)
1115 {
1116         struct smb_filename *stream_name = NULL;
1117         int ret;
1118         uint64_t rfork_size;
1119
1120         stream_name = synthetic_smb_fname(talloc_tos(),
1121                                           smb_fname->base_name,
1122                                           AFPRESOURCE_STREAM_NAME,
1123                                           NULL,
1124                                           smb_fname->twrp,
1125                                           0);
1126         if (stream_name == NULL) {
1127                 return 0;
1128         }
1129
1130         ret = SMB_VFS_STAT(handle->conn, stream_name);
1131         if (ret != 0) {
1132                 TALLOC_FREE(stream_name);
1133                 return 0;
1134         }
1135
1136         rfork_size = stream_name->st.st_ex_size;
1137         TALLOC_FREE(stream_name);
1138
1139         return rfork_size;
1140 }
1141
1142 static uint64_t readdir_attr_rfork_size(struct vfs_handle_struct *handle,
1143                                         const struct smb_filename *smb_fname)
1144 {
1145         struct fruit_config_data *config = NULL;
1146         uint64_t rfork_size;
1147
1148         SMB_VFS_HANDLE_GET_DATA(handle, config,
1149                                 struct fruit_config_data,
1150                                 return 0);
1151
1152         switch (config->rsrc) {
1153         case FRUIT_RSRC_ADFILE:
1154                 rfork_size = readdir_attr_rfork_size_adouble(handle,
1155                                                              smb_fname);
1156                 break;
1157
1158         case FRUIT_RSRC_XATTR:
1159         case FRUIT_RSRC_STREAM:
1160                 rfork_size = readdir_attr_rfork_size_stream(handle,
1161                                                             smb_fname);
1162                 break;
1163
1164         default:
1165                 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
1166                 rfork_size = 0;
1167                 break;
1168         }
1169
1170         return rfork_size;
1171 }
1172
1173 static NTSTATUS readdir_attr_macmeta(struct vfs_handle_struct *handle,
1174                                      const struct smb_filename *smb_fname,
1175                                      struct readdir_attr_data *attr_data)
1176 {
1177         NTSTATUS status = NT_STATUS_OK;
1178         struct fruit_config_data *config = NULL;
1179         bool ok;
1180
1181         SMB_VFS_HANDLE_GET_DATA(handle, config,
1182                                 struct fruit_config_data,
1183                                 return NT_STATUS_UNSUCCESSFUL);
1184
1185
1186         /* Ensure we return a default value in the creation_date field */
1187         RSIVAL(&attr_data->attr_data.aapl.finder_info, 12, AD_DATE_START);
1188
1189         /*
1190          * Resource fork length
1191          */
1192
1193         if (config->readdir_attr_rsize) {
1194                 uint64_t rfork_size;
1195
1196                 rfork_size = readdir_attr_rfork_size(handle, smb_fname);
1197                 attr_data->attr_data.aapl.rfork_size = rfork_size;
1198         }
1199
1200         /*
1201          * FinderInfo
1202          */
1203
1204         if (config->readdir_attr_finder_info) {
1205                 ok = readdir_attr_meta_finderi(handle, smb_fname, attr_data);
1206                 if (!ok) {
1207                         status = NT_STATUS_INTERNAL_ERROR;
1208                 }
1209         }
1210
1211         return status;
1212 }
1213
1214 static NTSTATUS remove_virtual_nfs_aces(struct security_descriptor *psd)
1215 {
1216         NTSTATUS status;
1217         uint32_t i;
1218
1219         if (psd->dacl == NULL) {
1220                 return NT_STATUS_OK;
1221         }
1222
1223         for (i = 0; i < psd->dacl->num_aces; i++) {
1224                 /* MS NFS style mode/uid/gid */
1225                 int cmp = dom_sid_compare_domain(
1226                                 &global_sid_Unix_NFS,
1227                                 &psd->dacl->aces[i].trustee);
1228                 if (cmp != 0) {
1229                         /* Normal ACE entry. */
1230                         continue;
1231                 }
1232
1233                 /*
1234                  * security_descriptor_dacl_del()
1235                  * *must* return NT_STATUS_OK as we know
1236                  * we have something to remove.
1237                  */
1238
1239                 status = security_descriptor_dacl_del(psd,
1240                                 &psd->dacl->aces[i].trustee);
1241                 if (!NT_STATUS_IS_OK(status)) {
1242                         DBG_WARNING("failed to remove MS NFS style ACE: %s\n",
1243                                 nt_errstr(status));
1244                         return status;
1245                 }
1246
1247                 /*
1248                  * security_descriptor_dacl_del() may delete more
1249                  * then one entry subsequent to this one if the
1250                  * SID matches, but we only need to ensure that
1251                  * we stay looking at the same element in the array.
1252                  */
1253                 i--;
1254         }
1255         return NT_STATUS_OK;
1256 }
1257
1258 /* Search MS NFS style ACE with UNIX mode */
1259 static NTSTATUS check_ms_nfs(vfs_handle_struct *handle,
1260                              files_struct *fsp,
1261                              struct security_descriptor *psd,
1262                              mode_t *pmode,
1263                              bool *pdo_chmod)
1264 {
1265         uint32_t i;
1266         struct fruit_config_data *config = NULL;
1267
1268         *pdo_chmod = false;
1269
1270         SMB_VFS_HANDLE_GET_DATA(handle, config,
1271                                 struct fruit_config_data,
1272                                 return NT_STATUS_UNSUCCESSFUL);
1273
1274         if (!global_fruit_config.nego_aapl) {
1275                 return NT_STATUS_OK;
1276         }
1277         if (psd->dacl == NULL || !config->unix_info_enabled) {
1278                 return NT_STATUS_OK;
1279         }
1280
1281         for (i = 0; i < psd->dacl->num_aces; i++) {
1282                 if (dom_sid_compare_domain(
1283                             &global_sid_Unix_NFS_Mode,
1284                             &psd->dacl->aces[i].trustee) == 0) {
1285                         *pmode = (mode_t)psd->dacl->aces[i].trustee.sub_auths[2];
1286                         *pmode &= (S_IRWXU | S_IRWXG | S_IRWXO);
1287                         *pdo_chmod = true;
1288
1289                         DEBUG(10, ("MS NFS chmod request %s, %04o\n",
1290                                    fsp_str_dbg(fsp), (unsigned)(*pmode)));
1291                         break;
1292                 }
1293         }
1294
1295         /*
1296          * Remove any incoming virtual ACE entries generated by
1297          * fruit_fget_nt_acl().
1298          */
1299
1300         return remove_virtual_nfs_aces(psd);
1301 }
1302
1303 /****************************************************************************
1304  * VFS ops
1305  ****************************************************************************/
1306
1307 static int fruit_connect(vfs_handle_struct *handle,
1308                          const char *service,
1309                          const char *user)
1310 {
1311         int rc;
1312         char *list = NULL, *newlist = NULL;
1313         struct fruit_config_data *config;
1314         const struct loadparm_substitution *lp_sub =
1315                 loadparm_s3_global_substitution();
1316
1317         DEBUG(10, ("fruit_connect\n"));
1318
1319         rc = SMB_VFS_NEXT_CONNECT(handle, service, user);
1320         if (rc < 0) {
1321                 return rc;
1322         }
1323
1324         rc = init_fruit_config(handle);
1325         if (rc != 0) {
1326                 return rc;
1327         }
1328
1329         SMB_VFS_HANDLE_GET_DATA(handle, config,
1330                                 struct fruit_config_data, return -1);
1331
1332         if (config->veto_appledouble) {
1333                 list = lp_veto_files(talloc_tos(), lp_sub, SNUM(handle->conn));
1334
1335                 if (list) {
1336                         if (strstr(list, "/" ADOUBLE_NAME_PREFIX "*/") == NULL) {
1337                                 newlist = talloc_asprintf(
1338                                         list,
1339                                         "%s/" ADOUBLE_NAME_PREFIX "*/",
1340                                         list);
1341                                 lp_do_parameter(SNUM(handle->conn),
1342                                                 "veto files",
1343                                                 newlist);
1344                         }
1345                 } else {
1346                         lp_do_parameter(SNUM(handle->conn),
1347                                         "veto files",
1348                                         "/" ADOUBLE_NAME_PREFIX "*/");
1349                 }
1350
1351                 TALLOC_FREE(list);
1352         }
1353
1354         if (config->encoding == FRUIT_ENC_NATIVE) {
1355                 lp_do_parameter(SNUM(handle->conn),
1356                                 "catia:mappings",
1357                                 macos_string_replace_map);
1358         }
1359
1360         if (config->time_machine) {
1361                 DBG_NOTICE("Enabling durable handles for Time Machine "
1362                            "support on [%s]\n", service);
1363                 lp_do_parameter(SNUM(handle->conn), "durable handles", "yes");
1364                 lp_do_parameter(SNUM(handle->conn), "kernel oplocks", "no");
1365                 lp_do_parameter(SNUM(handle->conn), "kernel share modes", "no");
1366                 if (!lp_strict_sync(SNUM(handle->conn))) {
1367                         DBG_WARNING("Time Machine without strict sync is not "
1368                                     "recommended!\n");
1369                 }
1370                 lp_do_parameter(SNUM(handle->conn), "posix locking", "no");
1371         }
1372
1373         return rc;
1374 }
1375
1376 static void fio_ref_destroy_fn(void *p_data)
1377 {
1378         struct fio *ref_fio = (struct fio *)p_data;
1379         if (ref_fio->real_fio != NULL) {
1380                 SMB_ASSERT(ref_fio->real_fio->ad_fsp == ref_fio->fsp);
1381                 ref_fio->real_fio->ad_fsp = NULL;
1382                 ref_fio->real_fio = NULL;
1383         }
1384 }
1385
1386 static void fio_close_ad_fsp(struct fio *fio)
1387 {
1388         if (fio->ad_fsp != NULL) {
1389                 fd_close(fio->ad_fsp);
1390                 file_free(NULL, fio->ad_fsp);
1391                 /* fio_ref_destroy_fn() should have cleared this */
1392                 SMB_ASSERT(fio->ad_fsp == NULL);
1393         }
1394 }
1395
1396 static void fio_destroy_fn(void *p_data)
1397 {
1398         struct fio *fio = (struct fio *)p_data;
1399         fio_close_ad_fsp(fio);
1400 }
1401
1402 static int fruit_open_meta_stream(vfs_handle_struct *handle,
1403                                   const struct files_struct *dirfsp,
1404                                   const struct smb_filename *smb_fname,
1405                                   files_struct *fsp,
1406                                   int flags,
1407                                   mode_t mode)
1408 {
1409         struct fruit_config_data *config = NULL;
1410         struct fio *fio = NULL;
1411         struct vfs_open_how how = {
1412                 .flags = flags & ~O_CREAT,
1413                 .mode = mode,
1414         };
1415         int fd;
1416
1417         DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
1418
1419         SMB_VFS_HANDLE_GET_DATA(handle, config,
1420                                 struct fruit_config_data, return -1);
1421
1422         fio = VFS_ADD_FSP_EXTENSION(handle, fsp, struct fio, fio_destroy_fn);
1423         fio->handle = handle;
1424         fio->fsp = fsp;
1425         fio->type = ADOUBLE_META;
1426         fio->config = config;
1427
1428         fd = SMB_VFS_NEXT_OPENAT(handle,
1429                                  dirfsp,
1430                                  smb_fname,
1431                                  fsp,
1432                                  &how);
1433         if (fd != -1) {
1434                 return fd;
1435         }
1436
1437         if (!(flags & O_CREAT)) {
1438                 VFS_REMOVE_FSP_EXTENSION(handle, fsp);
1439                 return -1;
1440         }
1441
1442         fd = vfs_fake_fd();
1443         if (fd == -1) {
1444                 VFS_REMOVE_FSP_EXTENSION(handle, fsp);
1445                 return -1;
1446         }
1447
1448         fio->fake_fd = true;
1449         fio->flags = flags;
1450         fio->mode = mode;
1451
1452         return fd;
1453 }
1454
1455 static int fruit_open_meta_netatalk(vfs_handle_struct *handle,
1456                                     const struct files_struct *dirfsp,
1457                                     const struct smb_filename *smb_fname,
1458                                     files_struct *fsp,
1459                                     int flags,
1460                                     mode_t mode)
1461 {
1462         struct fruit_config_data *config = NULL;
1463         struct fio *fio = NULL;
1464         struct adouble *ad = NULL;
1465         bool meta_exists = false;
1466         int fd;
1467
1468         DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
1469
1470         /*
1471          * We know this is a stream open, so fsp->base_fsp must
1472          * already be open.
1473          */
1474         SMB_ASSERT(fsp_is_alternate_stream(fsp));
1475         SMB_ASSERT(fsp->base_fsp->fsp_name->fsp == fsp->base_fsp);
1476
1477         ad = ad_get(talloc_tos(), handle, fsp->base_fsp->fsp_name, ADOUBLE_META);
1478         if (ad != NULL) {
1479                 meta_exists = true;
1480         }
1481
1482         TALLOC_FREE(ad);
1483
1484         if (!meta_exists && !(flags & O_CREAT)) {
1485                 errno = ENOENT;
1486                 return -1;
1487         }
1488
1489         fd = vfs_fake_fd();
1490         if (fd == -1) {
1491                 return -1;
1492         }
1493
1494         SMB_VFS_HANDLE_GET_DATA(handle, config,
1495                                 struct fruit_config_data, return -1);
1496
1497         fio = VFS_ADD_FSP_EXTENSION(handle, fsp, struct fio, fio_destroy_fn);
1498         fio->handle = handle;
1499         fio->fsp = fsp;
1500         fio->type = ADOUBLE_META;
1501         fio->config = config;
1502         fio->fake_fd = true;
1503         fio->flags = flags;
1504         fio->mode = mode;
1505
1506         return fd;
1507 }
1508
1509 static int fruit_open_meta(vfs_handle_struct *handle,
1510                            const struct files_struct *dirfsp,
1511                            const struct smb_filename *smb_fname,
1512                            files_struct *fsp, int flags, mode_t mode)
1513 {
1514         int fd;
1515         struct fruit_config_data *config = NULL;
1516
1517         DBG_DEBUG("path [%s]\n", smb_fname_str_dbg(smb_fname));
1518
1519         SMB_VFS_HANDLE_GET_DATA(handle, config,
1520                                 struct fruit_config_data, return -1);
1521
1522         switch (config->meta) {
1523         case FRUIT_META_STREAM:
1524                 fd = fruit_open_meta_stream(handle, dirfsp, smb_fname,
1525                                             fsp, flags, mode);
1526                 break;
1527
1528         case FRUIT_META_NETATALK:
1529                 fd = fruit_open_meta_netatalk(handle, dirfsp, smb_fname,
1530                                               fsp, flags, mode);
1531                 break;
1532
1533         default:
1534                 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
1535                 return -1;
1536         }
1537
1538         DBG_DEBUG("path [%s] fd [%d]\n", smb_fname_str_dbg(smb_fname), fd);
1539
1540         return fd;
1541 }
1542
1543 static int fruit_open_rsrc_adouble(vfs_handle_struct *handle,
1544                                    const struct files_struct *dirfsp,
1545                                    const struct smb_filename *smb_fname,
1546                                    files_struct *fsp,
1547                                    int flags,
1548                                    mode_t mode)
1549 {
1550         int rc = 0;
1551         struct fruit_config_data *config = NULL;
1552         struct files_struct *ad_fsp = NULL;
1553         struct fio *fio = NULL;
1554         struct fio *ref_fio = NULL;
1555         NTSTATUS status;
1556         int fd = -1;
1557
1558         SMB_VFS_HANDLE_GET_DATA(handle, config,
1559                                 struct fruit_config_data, return -1);
1560
1561         if ((!(flags & O_CREAT)) &&
1562             S_ISDIR(fsp->base_fsp->fsp_name->st.st_ex_mode))
1563         {
1564                 /* sorry, but directories don't have a resource fork */
1565                 errno = ENOENT;
1566                 rc = -1;
1567                 goto exit;
1568         }
1569
1570         /*
1571          * We return a fake_fd to the vfs modules above,
1572          * while we open an internal backend fsp for the
1573          * '._' file for the next vfs modules.
1574          *
1575          * Note that adouble_open_from_base_fsp() recurses
1576          * into fruit_openat(), but it'll just pass to
1577          * the next module as just opens a flat file on
1578          * disk.
1579          */
1580
1581         fd = vfs_fake_fd();
1582         if (fd == -1) {
1583                 rc = fd;
1584                 goto exit;
1585         }
1586
1587         status = adouble_open_from_base_fsp(fsp->conn->cwd_fsp,
1588                                             fsp->base_fsp,
1589                                             ADOUBLE_RSRC,
1590                                             flags,
1591                                             mode,
1592                                             &ad_fsp);
1593         if (!NT_STATUS_IS_OK(status)) {
1594                 errno = map_errno_from_nt_status(status);
1595                 rc = -1;
1596                 goto exit;
1597         }
1598
1599         /*
1600          * Now we need to glue both handles together,
1601          * so that they automatically detach each other
1602          * on close.
1603          */
1604         fio = fruit_get_complete_fio(handle, fsp);
1605         if (fio == NULL) {
1606                 DBG_ERR("fio=NULL for [%s]\n", fsp_str_dbg(fsp));
1607                 errno = EBADF;
1608                 rc = -1;
1609                 goto exit;
1610         }
1611
1612         ref_fio = VFS_ADD_FSP_EXTENSION(handle, ad_fsp,
1613                                         struct fio,
1614                                         fio_ref_destroy_fn);
1615         if (ref_fio == NULL) {
1616                 int saved_errno = errno;
1617                 fd_close(ad_fsp);
1618                 file_free(NULL, ad_fsp);
1619                 ad_fsp = NULL;
1620                 errno = saved_errno;
1621                 rc = -1;
1622                 goto exit;
1623         }
1624
1625         SMB_ASSERT(ref_fio->fsp == NULL);
1626         ref_fio->handle = handle;
1627         ref_fio->fsp = ad_fsp;
1628         ref_fio->type = ADOUBLE_RSRC;
1629         ref_fio->config = config;
1630         ref_fio->real_fio = fio;
1631         SMB_ASSERT(fio->ad_fsp == NULL);
1632         fio->ad_fsp = ad_fsp;
1633         fio->fake_fd = true;
1634
1635 exit:
1636
1637         DEBUG(10, ("fruit_open resource fork: rc=%d\n", rc));
1638         if (rc != 0) {
1639                 int saved_errno = errno;
1640                 if (fd != -1) {
1641                         vfs_fake_fd_close(fd);
1642                 }
1643                 errno = saved_errno;
1644                 return rc;
1645         }
1646         return fd;
1647 }
1648
1649 static int fruit_open_rsrc_xattr(vfs_handle_struct *handle,
1650                                  const struct files_struct *dirfsp,
1651                                  const struct smb_filename *smb_fname,
1652                                  files_struct *fsp,
1653                                  int flags,
1654                                  mode_t mode)
1655 {
1656 #ifdef HAVE_ATTROPEN
1657         int fd = -1;
1658
1659         /*
1660          * As there's no attropenat() this is only going to work with AT_FDCWD.
1661          */
1662         SMB_ASSERT(fsp_get_pathref_fd(dirfsp) == AT_FDCWD);
1663
1664         fd = attropen(smb_fname->base_name,
1665                       AFPRESOURCE_EA_NETATALK,
1666                       flags,
1667                       mode);
1668         if (fd == -1) {
1669                 return -1;
1670         }
1671
1672         return fd;
1673
1674 #else
1675         errno = ENOSYS;
1676         return -1;
1677 #endif
1678 }
1679
1680 static int fruit_open_rsrc(vfs_handle_struct *handle,
1681                            const struct files_struct *dirfsp,
1682                            const struct smb_filename *smb_fname,
1683                            files_struct *fsp, int flags, mode_t mode)
1684 {
1685         int fd;
1686         struct fruit_config_data *config = NULL;
1687         struct fio *fio = NULL;
1688
1689         DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
1690
1691         SMB_VFS_HANDLE_GET_DATA(handle, config,
1692                                 struct fruit_config_data, return -1);
1693
1694         fio = VFS_ADD_FSP_EXTENSION(handle, fsp, struct fio, fio_destroy_fn);
1695         fio->handle = handle;
1696         fio->fsp = fsp;
1697         fio->type = ADOUBLE_RSRC;
1698         fio->config = config;
1699
1700         switch (config->rsrc) {
1701         case FRUIT_RSRC_STREAM: {
1702                 struct vfs_open_how how = {
1703                         .flags = flags, .mode = mode,
1704                 };
1705                 fd = SMB_VFS_NEXT_OPENAT(handle,
1706                                          dirfsp,
1707                                          smb_fname,
1708                                          fsp,
1709                                          &how);
1710                 break;
1711         }
1712
1713         case FRUIT_RSRC_ADFILE:
1714                 fd = fruit_open_rsrc_adouble(handle, dirfsp, smb_fname,
1715                                              fsp, flags, mode);
1716                 break;
1717
1718         case FRUIT_RSRC_XATTR:
1719                 fd = fruit_open_rsrc_xattr(handle, dirfsp, smb_fname,
1720                                            fsp, flags, mode);
1721                 break;
1722
1723         default:
1724                 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
1725                 errno = EINVAL;
1726                 return -1;
1727         }
1728
1729         DBG_DEBUG("Path [%s] fd [%d]\n", smb_fname_str_dbg(smb_fname), fd);
1730
1731         if (fd == -1) {
1732                 return -1;
1733         }
1734
1735         return fd;
1736 }
1737
1738 static int fruit_openat(vfs_handle_struct *handle,
1739                         const struct files_struct *dirfsp,
1740                         const struct smb_filename *smb_fname,
1741                         files_struct *fsp,
1742                         const struct vfs_open_how *how)
1743 {
1744         int fd;
1745
1746         DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
1747
1748         if (!is_named_stream(smb_fname)) {
1749                 return SMB_VFS_NEXT_OPENAT(handle,
1750                                            dirfsp,
1751                                            smb_fname,
1752                                            fsp,
1753                                            how);
1754         }
1755
1756         if (how->resolve != 0) {
1757                 errno = ENOSYS;
1758                 return -1;
1759         }
1760
1761         SMB_ASSERT(fsp_is_alternate_stream(fsp));
1762
1763         if (is_afpinfo_stream(smb_fname->stream_name)) {
1764                 fd = fruit_open_meta(handle,
1765                                      dirfsp,
1766                                      smb_fname,
1767                                      fsp,
1768                                      how->flags,
1769                                      how->mode);
1770         } else if (is_afpresource_stream(smb_fname->stream_name)) {
1771                 fd = fruit_open_rsrc(handle,
1772                                      dirfsp,
1773                                      smb_fname,
1774                                      fsp,
1775                                      how->flags,
1776                                      how->mode);
1777         } else {
1778                 fd = SMB_VFS_NEXT_OPENAT(handle,
1779                                          dirfsp,
1780                                          smb_fname,
1781                                          fsp,
1782                                          how);
1783         }
1784
1785         DBG_DEBUG("Path [%s] fd [%d]\n", smb_fname_str_dbg(smb_fname), fd);
1786
1787         /* Prevent reopen optimisation */
1788         fsp->fsp_flags.have_proc_fds = false;
1789         return fd;
1790 }
1791
1792 static int fruit_close_meta(vfs_handle_struct *handle,
1793                             files_struct *fsp)
1794 {
1795         int ret;
1796         struct fruit_config_data *config = NULL;
1797
1798         SMB_VFS_HANDLE_GET_DATA(handle, config,
1799                                 struct fruit_config_data, return -1);
1800
1801         switch (config->meta) {
1802         case FRUIT_META_STREAM:
1803         {
1804                 struct fio *fio = fruit_get_complete_fio(handle, fsp);
1805                 if (fio == NULL) {
1806                         return -1;
1807                 }
1808                 if (fio->fake_fd) {
1809                         ret = vfs_fake_fd_close(fsp_get_pathref_fd(fsp));
1810                         fsp_set_fd(fsp, -1);
1811                 } else {
1812                         ret = SMB_VFS_NEXT_CLOSE(handle, fsp);
1813                 }
1814                 break;
1815         }
1816         case FRUIT_META_NETATALK:
1817                 ret = vfs_fake_fd_close(fsp_get_pathref_fd(fsp));
1818                 fsp_set_fd(fsp, -1);
1819                 break;
1820
1821         default:
1822                 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
1823                 return -1;
1824         }
1825
1826         return ret;
1827 }
1828
1829
1830 static int fruit_close_rsrc(vfs_handle_struct *handle,
1831                             files_struct *fsp)
1832 {
1833         int ret;
1834         struct fruit_config_data *config = NULL;
1835
1836         SMB_VFS_HANDLE_GET_DATA(handle, config,
1837                                 struct fruit_config_data, return -1);
1838
1839         switch (config->rsrc) {
1840         case FRUIT_RSRC_STREAM:
1841                 ret = SMB_VFS_NEXT_CLOSE(handle, fsp);
1842                 break;
1843
1844         case FRUIT_RSRC_ADFILE:
1845         {
1846                 struct fio *fio = fruit_get_complete_fio(handle, fsp);
1847                 if (fio == NULL) {
1848                         return -1;
1849                 }
1850                 fio_close_ad_fsp(fio);
1851                 ret = vfs_fake_fd_close(fsp_get_pathref_fd(fsp));
1852                 fsp_set_fd(fsp, -1);
1853                 break;
1854         }
1855
1856         case FRUIT_RSRC_XATTR:
1857                 ret = vfs_fake_fd_close(fsp_get_pathref_fd(fsp));
1858                 fsp_set_fd(fsp, -1);
1859                 break;
1860
1861         default:
1862                 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
1863                 return -1;
1864         }
1865
1866         return ret;
1867 }
1868
1869 static int fruit_close(vfs_handle_struct *handle,
1870                        files_struct *fsp)
1871 {
1872         int ret;
1873         int fd;
1874
1875         fd = fsp_get_pathref_fd(fsp);
1876
1877         DBG_DEBUG("Path [%s] fd [%d]\n", smb_fname_str_dbg(fsp->fsp_name), fd);
1878
1879         if (!fsp_is_alternate_stream(fsp)) {
1880                 return SMB_VFS_NEXT_CLOSE(handle, fsp);
1881         }
1882
1883         if (is_afpinfo_stream(fsp->fsp_name->stream_name)) {
1884                 ret = fruit_close_meta(handle, fsp);
1885         } else if (is_afpresource_stream(fsp->fsp_name->stream_name)) {
1886                 ret = fruit_close_rsrc(handle, fsp);
1887         } else {
1888                 ret = SMB_VFS_NEXT_CLOSE(handle, fsp);
1889         }
1890
1891         return ret;
1892 }
1893
1894 static int fruit_renameat(struct vfs_handle_struct *handle,
1895                         files_struct *srcfsp,
1896                         const struct smb_filename *smb_fname_src,
1897                         files_struct *dstfsp,
1898                         const struct smb_filename *smb_fname_dst)
1899 {
1900         int rc = -1;
1901         struct fruit_config_data *config = NULL;
1902         struct smb_filename *src_adp_smb_fname = NULL;
1903         struct smb_filename *dst_adp_smb_fname = NULL;
1904
1905         SMB_VFS_HANDLE_GET_DATA(handle, config,
1906                                 struct fruit_config_data, return -1);
1907
1908         if (!VALID_STAT(smb_fname_src->st)) {
1909                 DBG_ERR("Need valid stat for [%s]\n",
1910                         smb_fname_str_dbg(smb_fname_src));
1911                 return -1;
1912         }
1913
1914         rc = SMB_VFS_NEXT_RENAMEAT(handle,
1915                                 srcfsp,
1916                                 smb_fname_src,
1917                                 dstfsp,
1918                                 smb_fname_dst);
1919         if (rc != 0) {
1920                 return -1;
1921         }
1922
1923         if ((config->rsrc != FRUIT_RSRC_ADFILE) ||
1924             (!S_ISREG(smb_fname_src->st.st_ex_mode)))
1925         {
1926                 return 0;
1927         }
1928
1929         rc = adouble_path(talloc_tos(), smb_fname_src, &src_adp_smb_fname);
1930         if (rc != 0) {
1931                 goto done;
1932         }
1933
1934         rc = adouble_path(talloc_tos(), smb_fname_dst, &dst_adp_smb_fname);
1935         if (rc != 0) {
1936                 goto done;
1937         }
1938
1939         DBG_DEBUG("%s -> %s\n",
1940                   smb_fname_str_dbg(src_adp_smb_fname),
1941                   smb_fname_str_dbg(dst_adp_smb_fname));
1942
1943         rc = SMB_VFS_NEXT_RENAMEAT(handle,
1944                         srcfsp,
1945                         src_adp_smb_fname,
1946                         dstfsp,
1947                         dst_adp_smb_fname);
1948         if (errno == ENOENT) {
1949                 rc = 0;
1950         }
1951
1952 done:
1953         TALLOC_FREE(src_adp_smb_fname);
1954         TALLOC_FREE(dst_adp_smb_fname);
1955         return rc;
1956 }
1957
1958 static int fruit_unlink_meta_stream(vfs_handle_struct *handle,
1959                                 struct files_struct *dirfsp,
1960                                 const struct smb_filename *smb_fname)
1961 {
1962         return SMB_VFS_NEXT_UNLINKAT(handle,
1963                                 dirfsp,
1964                                 smb_fname,
1965                                 0);
1966 }
1967
1968 static int fruit_unlink_meta_netatalk(vfs_handle_struct *handle,
1969                                       const struct smb_filename *smb_fname)
1970 {
1971         SMB_ASSERT(smb_fname->fsp != NULL);
1972         SMB_ASSERT(fsp_is_alternate_stream(smb_fname->fsp));
1973         return SMB_VFS_FREMOVEXATTR(smb_fname->fsp->base_fsp,
1974                                    AFPINFO_EA_NETATALK);
1975 }
1976
1977 static int fruit_unlink_meta(vfs_handle_struct *handle,
1978                         struct files_struct *dirfsp,
1979                         const struct smb_filename *smb_fname)
1980 {
1981         struct fruit_config_data *config = NULL;
1982         int rc;
1983
1984         SMB_VFS_HANDLE_GET_DATA(handle, config,
1985                                 struct fruit_config_data, return -1);
1986
1987         switch (config->meta) {
1988         case FRUIT_META_STREAM:
1989                 rc = fruit_unlink_meta_stream(handle,
1990                                 dirfsp,
1991                                 smb_fname);
1992                 break;
1993
1994         case FRUIT_META_NETATALK:
1995                 rc = fruit_unlink_meta_netatalk(handle, smb_fname);
1996                 break;
1997
1998         default:
1999                 DBG_ERR("Unsupported meta config [%d]\n", config->meta);
2000                 return -1;
2001         }
2002
2003         return rc;
2004 }
2005
2006 static int fruit_unlink_rsrc_stream(vfs_handle_struct *handle,
2007                                 struct files_struct *dirfsp,
2008                                 const struct smb_filename *smb_fname,
2009                                 bool force_unlink)
2010 {
2011         int ret;
2012
2013         if (!force_unlink) {
2014                 struct smb_filename *full_fname = NULL;
2015                 off_t size;
2016
2017                 /*
2018                  * TODO: use SMB_VFS_STATX() once we have it.
2019                  */
2020
2021                 full_fname = full_path_from_dirfsp_atname(talloc_tos(),
2022                                                           dirfsp,
2023                                                           smb_fname);
2024                 if (full_fname == NULL) {
2025                         return -1;
2026                 }
2027
2028                 /*
2029                  * 0 byte resource fork streams are not listed by
2030                  * vfs_streaminfo, as a result stream cleanup/deletion of file
2031                  * deletion doesn't remove the resourcefork stream.
2032                  */
2033
2034                 ret = SMB_VFS_NEXT_STAT(handle, full_fname);
2035                 if (ret != 0) {
2036                         TALLOC_FREE(full_fname);
2037                         DBG_ERR("stat [%s] failed [%s]\n",
2038                                 smb_fname_str_dbg(full_fname), strerror(errno));
2039                         return -1;
2040                 }
2041
2042                 size = full_fname->st.st_ex_size;
2043                 TALLOC_FREE(full_fname);
2044
2045                 if (size > 0) {
2046                         /* OS X ignores resource fork stream delete requests */
2047                         return 0;
2048                 }
2049         }
2050
2051         ret = SMB_VFS_NEXT_UNLINKAT(handle,
2052                         dirfsp,
2053                         smb_fname,
2054                         0);
2055         if ((ret != 0) && (errno == ENOENT) && force_unlink) {
2056                 ret = 0;
2057         }
2058
2059         return ret;
2060 }
2061
2062 static int fruit_unlink_rsrc_adouble(vfs_handle_struct *handle,
2063                                 struct files_struct *dirfsp,
2064                                 const struct smb_filename *smb_fname,
2065                                 bool force_unlink)
2066 {
2067         int rc;
2068         struct adouble *ad = NULL;
2069         struct smb_filename *adp_smb_fname = NULL;
2070
2071         if (!force_unlink) {
2072                 struct smb_filename *full_fname = NULL;
2073
2074                 full_fname = full_path_from_dirfsp_atname(talloc_tos(),
2075                                                           dirfsp,
2076                                                           smb_fname);
2077                 if (full_fname == NULL) {
2078                         return -1;
2079                 }
2080
2081                 ad = ad_get(talloc_tos(), handle, full_fname,
2082                             ADOUBLE_RSRC);
2083                 TALLOC_FREE(full_fname);
2084                 if (ad == NULL) {
2085                         errno = ENOENT;
2086                         return -1;
2087                 }
2088
2089
2090                 /*
2091                  * 0 byte resource fork streams are not listed by
2092                  * vfs_streaminfo, as a result stream cleanup/deletion of file
2093                  * deletion doesn't remove the resourcefork stream.
2094                  */
2095
2096                 if (ad_getentrylen(ad, ADEID_RFORK) > 0) {
2097                         /* OS X ignores resource fork stream delete requests */
2098                         TALLOC_FREE(ad);
2099                         return 0;
2100                 }
2101
2102                 TALLOC_FREE(ad);
2103         }
2104
2105         rc = adouble_path(talloc_tos(), smb_fname, &adp_smb_fname);
2106         if (rc != 0) {
2107                 return -1;
2108         }
2109
2110         rc = SMB_VFS_NEXT_UNLINKAT(handle,
2111                         dirfsp,
2112                         adp_smb_fname,
2113                         0);
2114         TALLOC_FREE(adp_smb_fname);
2115         if ((rc != 0) && (errno == ENOENT || errno == ENAMETOOLONG) && force_unlink) {
2116                 rc = 0;
2117         }
2118
2119         return rc;
2120 }
2121
2122 static int fruit_unlink_rsrc_xattr(vfs_handle_struct *handle,
2123                                    const struct smb_filename *smb_fname,
2124                                    bool force_unlink)
2125 {
2126         /*
2127          * OS X ignores resource fork stream delete requests, so nothing to do
2128          * here. Removing the file will remove the xattr anyway, so we don't
2129          * have to take care of removing 0 byte resource forks that could be
2130          * left behind.
2131          */
2132         return 0;
2133 }
2134
2135 static int fruit_unlink_rsrc(vfs_handle_struct *handle,
2136                         struct files_struct *dirfsp,
2137                         const struct smb_filename *smb_fname,
2138                         bool force_unlink)
2139 {
2140         struct fruit_config_data *config = NULL;
2141         int rc;
2142
2143         SMB_VFS_HANDLE_GET_DATA(handle, config,
2144                                 struct fruit_config_data, return -1);
2145
2146         switch (config->rsrc) {
2147         case FRUIT_RSRC_STREAM:
2148                 rc = fruit_unlink_rsrc_stream(handle,
2149                                 dirfsp,
2150                                 smb_fname,
2151                                 force_unlink);
2152                 break;
2153
2154         case FRUIT_RSRC_ADFILE:
2155                 rc = fruit_unlink_rsrc_adouble(handle,
2156                                 dirfsp,
2157                                 smb_fname,
2158                                 force_unlink);
2159                 break;
2160
2161         case FRUIT_RSRC_XATTR:
2162                 rc = fruit_unlink_rsrc_xattr(handle, smb_fname, force_unlink);
2163                 break;
2164
2165         default:
2166                 DBG_ERR("Unsupported rsrc config [%d]\n", config->rsrc);
2167                 return -1;
2168         }
2169
2170         return rc;
2171 }
2172
2173 static int fruit_fchmod(vfs_handle_struct *handle,
2174                       struct files_struct *fsp,
2175                       mode_t mode)
2176 {
2177         int rc = -1;
2178         struct fruit_config_data *config = NULL;
2179         struct smb_filename *smb_fname_adp = NULL;
2180         const struct smb_filename *smb_fname = NULL;
2181         NTSTATUS status;
2182
2183         rc = SMB_VFS_NEXT_FCHMOD(handle, fsp, mode);
2184         if (rc != 0) {
2185                 return rc;
2186         }
2187
2188         smb_fname = fsp->fsp_name;
2189         SMB_VFS_HANDLE_GET_DATA(handle, config,
2190                                 struct fruit_config_data, return -1);
2191
2192         if (config->rsrc != FRUIT_RSRC_ADFILE) {
2193                 return 0;
2194         }
2195
2196         if (!VALID_STAT(smb_fname->st)) {
2197                 return 0;
2198         }
2199
2200         if (!S_ISREG(smb_fname->st.st_ex_mode)) {
2201                 return 0;
2202         }
2203
2204         rc = adouble_path(talloc_tos(), smb_fname, &smb_fname_adp);
2205         if (rc != 0) {
2206                 return -1;
2207         }
2208
2209         status = openat_pathref_fsp(handle->conn->cwd_fsp,
2210                                     smb_fname_adp);
2211         if (!NT_STATUS_IS_OK(status)) {
2212                 /* detect ENOENT (mapped to OBJECT_NAME_NOT_FOUND) */
2213                 if (NT_STATUS_EQUAL(status,
2214                                     NT_STATUS_OBJECT_NAME_NOT_FOUND)){
2215                         rc = 0;
2216                         goto out;
2217                 }
2218                 rc = -1;
2219                 goto out;
2220         }
2221
2222         DBG_DEBUG("%s\n", smb_fname_adp->base_name);
2223
2224         rc = SMB_VFS_NEXT_FCHMOD(handle, smb_fname_adp->fsp, mode);
2225         if (errno == ENOENT) {
2226                 rc = 0;
2227         }
2228 out:
2229         TALLOC_FREE(smb_fname_adp);
2230         return rc;
2231 }
2232
2233 static int fruit_unlinkat(vfs_handle_struct *handle,
2234                         struct files_struct *dirfsp,
2235                         const struct smb_filename *smb_fname,
2236                         int flags)
2237 {
2238         struct fruit_config_data *config = NULL;
2239         struct smb_filename *rsrc_smb_fname = NULL;
2240         int ret;
2241
2242         if (flags & AT_REMOVEDIR) {
2243                 return SMB_VFS_NEXT_UNLINKAT(handle,
2244                                              dirfsp,
2245                                              smb_fname,
2246                                              AT_REMOVEDIR);
2247         }
2248
2249         SMB_VFS_HANDLE_GET_DATA(handle, config,
2250                                 struct fruit_config_data, return -1);
2251
2252         if (is_afpinfo_stream(smb_fname->stream_name)) {
2253                 return fruit_unlink_meta(handle,
2254                                 dirfsp,
2255                                 smb_fname);
2256         } else if (is_afpresource_stream(smb_fname->stream_name)) {
2257                 return fruit_unlink_rsrc(handle,
2258                                 dirfsp,
2259                                 smb_fname,
2260                                 false);
2261         } else if (is_named_stream(smb_fname)) {
2262                 return SMB_VFS_NEXT_UNLINKAT(handle,
2263                                 dirfsp,
2264                                 smb_fname,
2265                                 0);
2266         } else if (is_adouble_file(smb_fname->base_name)) {
2267                 return SMB_VFS_NEXT_UNLINKAT(handle,
2268                                 dirfsp,
2269                                 smb_fname,
2270                                 0);
2271         }
2272
2273         /*
2274          * A request to delete the base file. Because 0 byte resource
2275          * fork streams are not listed by fruit_streaminfo,
2276          * delete_all_streams() can't remove 0 byte resource fork
2277          * streams, so we have to cleanup this here.
2278          */
2279         rsrc_smb_fname = synthetic_smb_fname(talloc_tos(),
2280                                              smb_fname->base_name,
2281                                              AFPRESOURCE_STREAM_NAME,
2282                                              NULL,
2283                                              smb_fname->twrp,
2284                                              smb_fname->flags);
2285         if (rsrc_smb_fname == NULL) {
2286                 return -1;
2287         }
2288
2289         ret = fruit_unlink_rsrc(handle, dirfsp, rsrc_smb_fname, true);
2290         if ((ret != 0) && (errno != ENOENT)) {
2291                 DBG_ERR("Forced unlink of [%s] failed [%s]\n",
2292                         smb_fname_str_dbg(rsrc_smb_fname), strerror(errno));
2293                 TALLOC_FREE(rsrc_smb_fname);
2294                 return -1;
2295         }
2296         TALLOC_FREE(rsrc_smb_fname);
2297
2298         return SMB_VFS_NEXT_UNLINKAT(handle,
2299                         dirfsp,
2300                         smb_fname,
2301                         0);
2302 }
2303
2304 static ssize_t fruit_pread_meta_stream(vfs_handle_struct *handle,
2305                                        files_struct *fsp, void *data,
2306                                        size_t n, off_t offset)
2307 {
2308         struct fio *fio = fruit_get_complete_fio(handle, fsp);
2309         ssize_t nread;
2310         int ret;
2311
2312         if ((fio == NULL) || fio->fake_fd) {
2313                 return -1;
2314         }
2315
2316         nread = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
2317         if (nread == -1 || nread == n) {
2318                 return nread;
2319         }
2320
2321         DBG_ERR("Removing [%s] after short read [%zd]\n",
2322                 fsp_str_dbg(fsp), nread);
2323
2324         ret = SMB_VFS_NEXT_UNLINKAT(handle,
2325                         fsp->conn->cwd_fsp,
2326                         fsp->fsp_name,
2327                         0);
2328         if (ret != 0) {
2329                 DBG_ERR("Removing [%s] failed\n", fsp_str_dbg(fsp));
2330                 return -1;
2331         }
2332
2333         errno = EINVAL;
2334         return -1;
2335 }
2336
2337 static ssize_t fruit_pread_meta_adouble(vfs_handle_struct *handle,
2338                                         files_struct *fsp, void *data,
2339                                         size_t n, off_t offset)
2340 {
2341         AfpInfo *ai = NULL;
2342         struct adouble *ad = NULL;
2343         char afpinfo_buf[AFP_INFO_SIZE];
2344         char *p = NULL;
2345         ssize_t nread;
2346
2347         ai = afpinfo_new(talloc_tos());
2348         if (ai == NULL) {
2349                 return -1;
2350         }
2351
2352         ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_META);
2353         if (ad == NULL) {
2354                 nread = -1;
2355                 goto fail;
2356         }
2357
2358         p = ad_get_entry(ad, ADEID_FINDERI);
2359         if (p == NULL) {
2360                 DBG_ERR("No ADEID_FINDERI for [%s]\n", fsp_str_dbg(fsp));
2361                 nread = -1;
2362                 goto fail;
2363         }
2364
2365         memcpy(&ai->afpi_FinderInfo[0], p, ADEDLEN_FINDERI);
2366
2367         nread = afpinfo_pack(ai, afpinfo_buf);
2368         if (nread != AFP_INFO_SIZE) {
2369                 nread = -1;
2370                 goto fail;
2371         }
2372
2373         memcpy(data, afpinfo_buf, n);
2374         nread = n;
2375
2376 fail:
2377         TALLOC_FREE(ai);
2378         return nread;
2379 }
2380
2381 static ssize_t fruit_pread_meta(vfs_handle_struct *handle,
2382                                 files_struct *fsp, void *data,
2383                                 size_t n, off_t offset)
2384 {
2385         struct fio *fio = fruit_get_complete_fio(handle, fsp);
2386         ssize_t nread;
2387         ssize_t to_return;
2388
2389         /*
2390          * OS X has a off-by-1 error in the offset calculation, so we're
2391          * bug compatible here. It won't hurt, as any relevant real
2392          * world read requests from the AFP_AfpInfo stream will be
2393          * offset=0 n=60. offset is ignored anyway, see below.
2394          */
2395         if ((offset < 0) || (offset >= AFP_INFO_SIZE + 1)) {
2396                 return 0;
2397         }
2398
2399         if (fio == NULL) {
2400                 DBG_ERR("Failed to fetch fsp extension\n");
2401                 return -1;
2402         }
2403
2404         /* Yes, macOS always reads from offset 0 */
2405         offset = 0;
2406         to_return = MIN(n, AFP_INFO_SIZE);
2407
2408         switch (fio->config->meta) {
2409         case FRUIT_META_STREAM:
2410                 nread = fruit_pread_meta_stream(handle, fsp, data,
2411                                                 to_return, offset);
2412                 break;
2413
2414         case FRUIT_META_NETATALK:
2415                 nread = fruit_pread_meta_adouble(handle, fsp, data,
2416                                                  to_return, offset);
2417                 break;
2418
2419         default:
2420                 DBG_ERR("Unexpected meta config [%d]\n", fio->config->meta);
2421                 return -1;
2422         }
2423
2424         if (nread == -1 && fio->fake_fd) {
2425                 AfpInfo *ai = NULL;
2426                 char afpinfo_buf[AFP_INFO_SIZE];
2427
2428                 ai = afpinfo_new(talloc_tos());
2429                 if (ai == NULL) {
2430                         return -1;
2431                 }
2432
2433                 nread = afpinfo_pack(ai, afpinfo_buf);
2434                 TALLOC_FREE(ai);
2435                 if (nread != AFP_INFO_SIZE) {
2436                         return -1;
2437                 }
2438
2439                 memcpy(data, afpinfo_buf, to_return);
2440                 return to_return;
2441         }
2442
2443         return nread;
2444 }
2445
2446 static ssize_t fruit_pread_rsrc_stream(vfs_handle_struct *handle,
2447                                        files_struct *fsp, void *data,
2448                                        size_t n, off_t offset)
2449 {
2450         return SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
2451 }
2452
2453 static ssize_t fruit_pread_rsrc_xattr(vfs_handle_struct *handle,
2454                                       files_struct *fsp, void *data,
2455                                       size_t n, off_t offset)
2456 {
2457         return SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
2458 }
2459
2460 static ssize_t fruit_pread_rsrc_adouble(vfs_handle_struct *handle,
2461                                         files_struct *fsp, void *data,
2462                                         size_t n, off_t offset)
2463 {
2464         struct fio *fio = fruit_get_complete_fio(handle, fsp);
2465         struct adouble *ad = NULL;
2466         ssize_t nread;
2467
2468         if (fio == NULL || fio->ad_fsp == NULL) {
2469                 DBG_ERR("fio/ad_fsp=NULL for [%s]\n", fsp_str_dbg(fsp));
2470                 errno = EBADF;
2471                 return -1;
2472         }
2473
2474         ad = ad_fget(talloc_tos(), handle, fio->ad_fsp, ADOUBLE_RSRC);
2475         if (ad == NULL) {
2476                 DBG_ERR("ad_fget [%s] failed [%s]\n",
2477                         fsp_str_dbg(fio->ad_fsp), strerror(errno));
2478                 return -1;
2479         }
2480
2481         nread = SMB_VFS_NEXT_PREAD(handle, fio->ad_fsp, data, n,
2482                                    offset + ad_getentryoff(ad, ADEID_RFORK));
2483
2484         TALLOC_FREE(ad);
2485         return nread;
2486 }
2487
2488 static ssize_t fruit_pread_rsrc(vfs_handle_struct *handle,
2489                                 files_struct *fsp, void *data,
2490                                 size_t n, off_t offset)
2491 {
2492         struct fio *fio = fruit_get_complete_fio(handle, fsp);
2493         ssize_t nread;
2494
2495         if (fio == NULL) {
2496                 errno = EINVAL;
2497                 return -1;
2498         }
2499
2500         switch (fio->config->rsrc) {
2501         case FRUIT_RSRC_STREAM:
2502                 nread = fruit_pread_rsrc_stream(handle, fsp, data, n, offset);
2503                 break;
2504
2505         case FRUIT_RSRC_ADFILE:
2506                 nread = fruit_pread_rsrc_adouble(handle, fsp, data, n, offset);
2507                 break;
2508
2509         case FRUIT_RSRC_XATTR:
2510                 nread = fruit_pread_rsrc_xattr(handle, fsp, data, n, offset);
2511                 break;
2512
2513         default:
2514                 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
2515                 return -1;
2516         }
2517
2518         return nread;
2519 }
2520
2521 static ssize_t fruit_pread(vfs_handle_struct *handle,
2522                            files_struct *fsp, void *data,
2523                            size_t n, off_t offset)
2524 {
2525         struct fio *fio = fruit_get_complete_fio(handle, fsp);
2526         ssize_t nread;
2527
2528         DBG_DEBUG("Path [%s] offset=%"PRIdMAX", size=%zd\n",
2529                   fsp_str_dbg(fsp), (intmax_t)offset, n);
2530
2531         if (fio == NULL) {
2532                 return SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
2533         }
2534
2535         if (fio->type == ADOUBLE_META) {
2536                 nread = fruit_pread_meta(handle, fsp, data, n, offset);
2537         } else {
2538                 nread = fruit_pread_rsrc(handle, fsp, data, n, offset);
2539         }
2540
2541         DBG_DEBUG("Path [%s] nread [%zd]\n", fsp_str_dbg(fsp), nread);
2542         return nread;
2543 }
2544
2545 static bool fruit_must_handle_aio_stream(struct fio *fio)
2546 {
2547         if (fio == NULL) {
2548                 return false;
2549         };
2550
2551         if (fio->type == ADOUBLE_META) {
2552                 return true;
2553         }
2554
2555         if ((fio->type == ADOUBLE_RSRC) &&
2556             (fio->config->rsrc == FRUIT_RSRC_ADFILE))
2557         {
2558                 return true;
2559         }
2560
2561         return false;
2562 }
2563
2564 struct fruit_pread_state {
2565         ssize_t nread;
2566         struct vfs_aio_state vfs_aio_state;
2567 };
2568
2569 static void fruit_pread_done(struct tevent_req *subreq);
2570
2571 static struct tevent_req *fruit_pread_send(
2572         struct vfs_handle_struct *handle,
2573         TALLOC_CTX *mem_ctx,
2574         struct tevent_context *ev,
2575         struct files_struct *fsp,
2576         void *data,
2577         size_t n, off_t offset)
2578 {
2579         struct tevent_req *req = NULL;
2580         struct tevent_req *subreq = NULL;
2581         struct fruit_pread_state *state = NULL;
2582         struct fio *fio = fruit_get_complete_fio(handle, fsp);
2583
2584         req = tevent_req_create(mem_ctx, &state,
2585                                 struct fruit_pread_state);
2586         if (req == NULL) {
2587                 return NULL;
2588         }
2589
2590         if (fruit_must_handle_aio_stream(fio)) {
2591                 state->nread = SMB_VFS_PREAD(fsp, data, n, offset);
2592                 if (state->nread != n) {
2593                         if (state->nread != -1) {
2594                                 errno = EIO;
2595                         }
2596                         tevent_req_error(req, errno);
2597                         return tevent_req_post(req, ev);
2598                 }
2599                 tevent_req_done(req);
2600                 return tevent_req_post(req, ev);
2601         }
2602
2603         subreq = SMB_VFS_NEXT_PREAD_SEND(state, ev, handle, fsp,
2604                                          data, n, offset);
2605         if (tevent_req_nomem(req, subreq)) {
2606                 return tevent_req_post(req, ev);
2607         }
2608         tevent_req_set_callback(subreq, fruit_pread_done, req);
2609         return req;
2610 }
2611
2612 static void fruit_pread_done(struct tevent_req *subreq)
2613 {
2614         struct tevent_req *req = tevent_req_callback_data(
2615                 subreq, struct tevent_req);
2616         struct fruit_pread_state *state = tevent_req_data(
2617                 req, struct fruit_pread_state);
2618
2619         state->nread = SMB_VFS_PREAD_RECV(subreq, &state->vfs_aio_state);
2620         TALLOC_FREE(subreq);
2621
2622         if (tevent_req_error(req, state->vfs_aio_state.error)) {
2623                 return;
2624         }
2625         tevent_req_done(req);
2626 }
2627
2628 static ssize_t fruit_pread_recv(struct tevent_req *req,
2629                                         struct vfs_aio_state *vfs_aio_state)
2630 {
2631         struct fruit_pread_state *state = tevent_req_data(
2632                 req, struct fruit_pread_state);
2633         ssize_t retval = -1;
2634
2635         if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
2636                 tevent_req_received(req);
2637                 return -1;
2638         }
2639
2640         *vfs_aio_state = state->vfs_aio_state;
2641         retval = state->nread;
2642         tevent_req_received(req);
2643         return retval;
2644 }
2645
2646 static ssize_t fruit_pwrite_meta_stream(vfs_handle_struct *handle,
2647                                         files_struct *fsp, const void *indata,
2648                                         size_t n, off_t offset)
2649 {
2650         struct fio *fio = fruit_get_complete_fio(handle, fsp);
2651         const void *data = indata;
2652         char afpinfo_buf[AFP_INFO_SIZE];
2653         AfpInfo *ai = NULL;
2654         size_t nwritten;
2655         int ret;
2656         bool ok;
2657
2658         DBG_DEBUG("Path [%s] offset=%"PRIdMAX", size=%zd\n",
2659                   fsp_str_dbg(fsp), (intmax_t)offset, n);
2660
2661         if (fio == NULL) {
2662                 return -1;
2663         }
2664
2665         if (fio->fake_fd) {
2666                 struct vfs_open_how how = {
2667                         .flags = fio->flags, .mode = fio->mode,
2668                 };
2669                 int fd = fsp_get_pathref_fd(fsp);
2670
2671                 ret = vfs_fake_fd_close(fd);
2672                 fsp_set_fd(fsp, -1);
2673                 if (ret != 0) {
2674                         DBG_ERR("Close [%s] failed: %s\n",
2675                                 fsp_str_dbg(fsp), strerror(errno));
2676                         return -1;
2677                 }
2678
2679                 fd = SMB_VFS_NEXT_OPENAT(handle,
2680                                          NULL, /* opening a stream */
2681                                          fsp->fsp_name,
2682                                          fsp,
2683                                          &how);
2684                 if (fd == -1) {
2685                         DBG_ERR("On-demand create [%s] in write failed: %s\n",
2686                                 fsp_str_dbg(fsp), strerror(errno));
2687                         return -1;
2688                 }
2689                 fsp_set_fd(fsp, fd);
2690                 fio->fake_fd = false;
2691         }
2692
2693         ai = afpinfo_unpack(talloc_tos(), data, fio->config->validate_afpinfo);
2694         if (ai == NULL) {
2695                 return -1;
2696         }
2697
2698         if (ai_empty_finderinfo(ai)) {
2699                 /*
2700                  * Writing an all 0 blob to the metadata stream results in the
2701                  * stream being removed on a macOS server. This ensures we
2702                  * behave the same and it verified by the "delete AFP_AfpInfo by
2703                  * writing all 0" test.
2704                  */
2705                 ret = SMB_VFS_NEXT_FTRUNCATE(handle, fsp, 0);
2706                 if (ret != 0) {
2707                         DBG_ERR("SMB_VFS_NEXT_FTRUNCATE on [%s] failed\n",
2708                                 fsp_str_dbg(fsp));
2709                         return -1;
2710                 }
2711
2712                 ok = set_delete_on_close(
2713                         fsp,
2714                         true,
2715                         handle->conn->session_info->security_token,
2716                         handle->conn->session_info->unix_token);
2717                 if (!ok) {
2718                         DBG_ERR("set_delete_on_close on [%s] failed\n",
2719                                 fsp_str_dbg(fsp));
2720                         return -1;
2721                 }
2722                 return n;
2723         }
2724
2725         if (!fio->config->validate_afpinfo) {
2726                 /*
2727                  * Ensure the buffer contains a valid header, so marshall
2728                  * the data from the afpinfo struck back into a buffer
2729                  * and write that instead of the possibly malformed data
2730                  * we got from the client.
2731                  */
2732                 nwritten = afpinfo_pack(ai, afpinfo_buf);
2733                 if (nwritten != AFP_INFO_SIZE) {
2734                         errno = EINVAL;
2735                         return -1;
2736                 }
2737                 data = afpinfo_buf;
2738         }
2739
2740         nwritten = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
2741         if (nwritten != n) {
2742                 return -1;
2743         }
2744
2745         return n;
2746 }
2747
2748 static ssize_t fruit_pwrite_meta_netatalk(vfs_handle_struct *handle,
2749                                           files_struct *fsp, const void *data,
2750                                           size_t n, off_t offset)
2751 {
2752         struct fruit_config_data *config = NULL;
2753         struct adouble *ad = NULL;
2754         AfpInfo *ai = NULL;
2755         char *p = NULL;
2756         int ret;
2757         bool ok;
2758
2759         SMB_VFS_HANDLE_GET_DATA(handle, config,
2760                                 struct fruit_config_data, return -1);
2761
2762         ai = afpinfo_unpack(talloc_tos(), data, config->validate_afpinfo);
2763         if (ai == NULL) {
2764                 return -1;
2765         }
2766
2767         ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_META);
2768         if (ad == NULL) {
2769                 ad = ad_init(talloc_tos(), ADOUBLE_META);
2770                 if (ad == NULL) {
2771                         return -1;
2772                 }
2773         }
2774         p = ad_get_entry(ad, ADEID_FINDERI);
2775         if (p == NULL) {
2776                 DBG_ERR("No ADEID_FINDERI for [%s]\n", fsp_str_dbg(fsp));
2777                 TALLOC_FREE(ad);
2778                 return -1;
2779         }
2780
2781         memcpy(p, &ai->afpi_FinderInfo[0], ADEDLEN_FINDERI);
2782
2783         ret = ad_fset(handle, ad, fsp);
2784         if (ret != 0) {
2785                 DBG_ERR("ad_pwrite [%s] failed\n", fsp_str_dbg(fsp));
2786                 TALLOC_FREE(ad);
2787                 return -1;
2788         }
2789
2790         TALLOC_FREE(ad);
2791
2792         if (!ai_empty_finderinfo(ai)) {
2793                 return n;
2794         }
2795
2796         /*
2797          * Writing an all 0 blob to the metadata stream results in the stream
2798          * being removed on a macOS server. This ensures we behave the same and
2799          * it verified by the "delete AFP_AfpInfo by writing all 0" test.
2800          */
2801
2802         ok = set_delete_on_close(
2803                 fsp,
2804                 true,
2805                 handle->conn->session_info->security_token,
2806                 handle->conn->session_info->unix_token);
2807         if (!ok) {
2808                 DBG_ERR("set_delete_on_close on [%s] failed\n",
2809                         fsp_str_dbg(fsp));
2810                 return -1;
2811         }
2812
2813         return n;
2814 }
2815
2816 static ssize_t fruit_pwrite_meta(vfs_handle_struct *handle,
2817                                  files_struct *fsp, const void *data,
2818                                  size_t n, off_t offset)
2819 {
2820         struct fio *fio = fruit_get_complete_fio(handle, fsp);
2821         ssize_t nwritten;
2822         uint8_t buf[AFP_INFO_SIZE];
2823         size_t to_write;
2824         size_t to_copy;
2825         int cmp;
2826
2827         if (fio == NULL) {
2828                 DBG_ERR("Failed to fetch fsp extension\n");
2829                 return -1;
2830         }
2831
2832         if (n < 3) {
2833                 errno = EINVAL;
2834                 return -1;
2835         }
2836
2837         if (offset != 0 && n < 60) {
2838                 errno = EINVAL;
2839                 return -1;
2840         }
2841
2842         if (fio->config->validate_afpinfo) {
2843                 cmp = memcmp(data, "AFP", 3);
2844                 if (cmp != 0) {
2845                         errno = EINVAL;
2846                         return -1;
2847                 }
2848         }
2849
2850         if (n <= AFP_OFF_FinderInfo) {
2851                 /*
2852                  * Nothing to do here really, just return
2853                  */
2854                 return n;
2855         }
2856
2857         offset = 0;
2858
2859         to_copy = n;
2860         if (to_copy > AFP_INFO_SIZE) {
2861                 to_copy = AFP_INFO_SIZE;
2862         }
2863         memcpy(buf, data, to_copy);
2864
2865         to_write = n;
2866         if (to_write != AFP_INFO_SIZE) {
2867                 to_write = AFP_INFO_SIZE;
2868         }
2869
2870         switch (fio->config->meta) {
2871         case FRUIT_META_STREAM:
2872                 nwritten = fruit_pwrite_meta_stream(handle,
2873                                                     fsp,
2874                                                     buf,
2875                                                     to_write,
2876                                                     offset);
2877                 break;
2878
2879         case FRUIT_META_NETATALK:
2880                 nwritten = fruit_pwrite_meta_netatalk(handle,
2881                                                       fsp,
2882                                                       buf,
2883                                                       to_write,
2884                                                       offset);
2885                 break;
2886
2887         default:
2888                 DBG_ERR("Unexpected meta config [%d]\n", fio->config->meta);
2889                 return -1;
2890         }
2891
2892         if (nwritten != to_write) {
2893                 return -1;
2894         }
2895
2896         /*
2897          * Return the requested amount, verified against macOS SMB server
2898          */
2899         return n;
2900 }
2901
2902 static ssize_t fruit_pwrite_rsrc_stream(vfs_handle_struct *handle,
2903                                         files_struct *fsp, const void *data,
2904                                         size_t n, off_t offset)
2905 {
2906         return SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
2907 }
2908
2909 static ssize_t fruit_pwrite_rsrc_xattr(vfs_handle_struct *handle,
2910                                        files_struct *fsp, const void *data,
2911                                        size_t n, off_t offset)
2912 {
2913         return SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
2914 }
2915
2916 static ssize_t fruit_pwrite_rsrc_adouble(vfs_handle_struct *handle,
2917                                          files_struct *fsp, const void *data,
2918                                          size_t n, off_t offset)
2919 {
2920         struct fio *fio = fruit_get_complete_fio(handle, fsp);
2921         struct adouble *ad = NULL;
2922         ssize_t nwritten;
2923         int ret;
2924
2925         if (fio == NULL || fio->ad_fsp == NULL) {
2926                 DBG_ERR("fio/ad_fsp=NULL for [%s]\n", fsp_str_dbg(fsp));
2927                 errno = EBADF;
2928                 return -1;
2929         }
2930
2931         ad = ad_fget(talloc_tos(), handle, fio->ad_fsp, ADOUBLE_RSRC);
2932         if (ad == NULL) {
2933                 DBG_ERR("ad_fget [%s] failed [%s]\n",
2934                         fsp_str_dbg(fio->ad_fsp), strerror(errno));
2935                 return -1;
2936         }
2937
2938         nwritten = SMB_VFS_NEXT_PWRITE(handle, fio->ad_fsp, data, n,
2939                                        offset + ad_getentryoff(ad, ADEID_RFORK));
2940         if (nwritten != n) {
2941                 DBG_ERR("Short write on [%s] [%zd/%zd]\n",
2942                         fsp_str_dbg(fio->ad_fsp), nwritten, n);
2943                 TALLOC_FREE(ad);
2944                 return -1;
2945         }
2946
2947         if ((n + offset) > ad_getentrylen(ad, ADEID_RFORK)) {
2948                 ad_setentrylen(ad, ADEID_RFORK, n + offset);
2949                 ret = ad_fset(handle, ad, fio->ad_fsp);
2950                 if (ret != 0) {
2951                         DBG_ERR("ad_pwrite [%s] failed\n", fsp_str_dbg(fio->ad_fsp));
2952                         TALLOC_FREE(ad);
2953                         return -1;
2954                 }
2955         }
2956
2957         TALLOC_FREE(ad);
2958         return n;
2959 }
2960
2961 static ssize_t fruit_pwrite_rsrc(vfs_handle_struct *handle,
2962                                  files_struct *fsp, const void *data,
2963                                  size_t n, off_t offset)
2964 {
2965         struct fio *fio = fruit_get_complete_fio(handle, fsp);
2966         ssize_t nwritten;
2967
2968         if (fio == NULL) {
2969                 DBG_ERR("Failed to fetch fsp extension\n");
2970                 return -1;
2971         }
2972
2973         switch (fio->config->rsrc) {
2974         case FRUIT_RSRC_STREAM:
2975                 nwritten = fruit_pwrite_rsrc_stream(handle, fsp, data, n, offset);
2976                 break;
2977
2978         case FRUIT_RSRC_ADFILE:
2979                 nwritten = fruit_pwrite_rsrc_adouble(handle, fsp, data, n, offset);
2980                 break;
2981
2982         case FRUIT_RSRC_XATTR:
2983                 nwritten = fruit_pwrite_rsrc_xattr(handle, fsp, data, n, offset);
2984                 break;
2985
2986         default:
2987                 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
2988                 return -1;
2989         }
2990
2991         return nwritten;
2992 }
2993
2994 static ssize_t fruit_pwrite(vfs_handle_struct *handle,
2995                             files_struct *fsp, const void *data,
2996                             size_t n, off_t offset)
2997 {
2998         struct fio *fio = fruit_get_complete_fio(handle, fsp);
2999         ssize_t nwritten;
3000
3001         DBG_DEBUG("Path [%s] offset=%"PRIdMAX", size=%zd\n",
3002                   fsp_str_dbg(fsp), (intmax_t)offset, n);
3003
3004         if (fio == NULL) {
3005                 return SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
3006         }
3007
3008         if (fio->type == ADOUBLE_META) {
3009                 nwritten = fruit_pwrite_meta(handle, fsp, data, n, offset);
3010         } else {
3011                 nwritten = fruit_pwrite_rsrc(handle, fsp, data, n, offset);
3012         }
3013
3014         DBG_DEBUG("Path [%s] nwritten=%zd\n", fsp_str_dbg(fsp), nwritten);
3015         return nwritten;
3016 }
3017
3018 struct fruit_pwrite_state {
3019         ssize_t nwritten;
3020         struct vfs_aio_state vfs_aio_state;
3021 };
3022
3023 static void fruit_pwrite_done(struct tevent_req *subreq);
3024
3025 static struct tevent_req *fruit_pwrite_send(
3026         struct vfs_handle_struct *handle,
3027         TALLOC_CTX *mem_ctx,
3028         struct tevent_context *ev,
3029         struct files_struct *fsp,
3030         const void *data,
3031         size_t n, off_t offset)
3032 {
3033         struct tevent_req *req = NULL;
3034         struct tevent_req *subreq = NULL;
3035         struct fruit_pwrite_state *state = NULL;
3036         struct fio *fio = fruit_get_complete_fio(handle, fsp);
3037
3038         req = tevent_req_create(mem_ctx, &state,
3039                                 struct fruit_pwrite_state);
3040         if (req == NULL) {
3041                 return NULL;
3042         }
3043
3044         if (fruit_must_handle_aio_stream(fio)) {
3045                 state->nwritten = SMB_VFS_PWRITE(fsp, data, n, offset);
3046                 if (state->nwritten != n) {
3047                         if (state->nwritten != -1) {
3048                                 errno = EIO;
3049                         }
3050                         tevent_req_error(req, errno);
3051                         return tevent_req_post(req, ev);
3052                 }
3053                 tevent_req_done(req);
3054                 return tevent_req_post(req, ev);
3055         }
3056
3057         subreq = SMB_VFS_NEXT_PWRITE_SEND(state, ev, handle, fsp,
3058                                           data, n, offset);
3059         if (tevent_req_nomem(req, subreq)) {
3060                 return tevent_req_post(req, ev);
3061         }
3062         tevent_req_set_callback(subreq, fruit_pwrite_done, req);
3063         return req;
3064 }
3065
3066 static void fruit_pwrite_done(struct tevent_req *subreq)
3067 {
3068         struct tevent_req *req = tevent_req_callback_data(
3069                 subreq, struct tevent_req);
3070         struct fruit_pwrite_state *state = tevent_req_data(
3071                 req, struct fruit_pwrite_state);
3072
3073         state->nwritten = SMB_VFS_PWRITE_RECV(subreq, &state->vfs_aio_state);
3074         TALLOC_FREE(subreq);
3075
3076         if (tevent_req_error(req, state->vfs_aio_state.error)) {
3077                 return;
3078         }
3079         tevent_req_done(req);
3080 }
3081
3082 static ssize_t fruit_pwrite_recv(struct tevent_req *req,
3083                                          struct vfs_aio_state *vfs_aio_state)
3084 {
3085         struct fruit_pwrite_state *state = tevent_req_data(
3086                 req, struct fruit_pwrite_state);
3087         ssize_t retval = -1;
3088
3089         if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
3090                 tevent_req_received(req);
3091                 return -1;
3092         }
3093
3094         *vfs_aio_state = state->vfs_aio_state;
3095         retval = state->nwritten;
3096         tevent_req_received(req);
3097         return retval;
3098 }
3099
3100 struct fruit_fsync_state {
3101         int ret;
3102         struct vfs_aio_state vfs_aio_state;
3103 };
3104
3105 static void fruit_fsync_done(struct tevent_req *subreq);
3106
3107 static struct tevent_req *fruit_fsync_send(
3108         struct vfs_handle_struct *handle,
3109         TALLOC_CTX *mem_ctx,
3110         struct tevent_context *ev,
3111         struct files_struct *fsp)
3112 {
3113         struct tevent_req *req = NULL;
3114         struct tevent_req *subreq = NULL;
3115         struct fruit_fsync_state *state = NULL;
3116         struct fio *fio = fruit_get_complete_fio(handle, fsp);
3117
3118         req = tevent_req_create(mem_ctx, &state,
3119                                 struct fruit_fsync_state);
3120         if (req == NULL) {
3121                 return NULL;
3122         }
3123
3124         if (fruit_must_handle_aio_stream(fio)) {
3125                 struct adouble *ad = NULL;
3126
3127                 if (fio->type == ADOUBLE_META) {
3128                         /*
3129                          * We must never pass a fake_fd
3130                          * to lower level fsync calls.
3131                          * Everything is already done
3132                          * synchronously, so just return
3133                          * true.
3134                          */
3135                         SMB_ASSERT(fio->fake_fd);
3136                         tevent_req_done(req);
3137                         return tevent_req_post(req, ev);
3138                 }
3139
3140                 /*
3141                  * We know the following must be true,
3142                  * as it's the condition for fruit_must_handle_aio_stream()
3143                  * to return true if fio->type == ADOUBLE_RSRC.
3144                  */
3145                 SMB_ASSERT(fio->config->rsrc == FRUIT_RSRC_ADFILE);
3146                 if (fio->ad_fsp == NULL) {
3147                         tevent_req_error(req, EBADF);
3148                         return tevent_req_post(req, ev);
3149                 }
3150                 ad = ad_fget(talloc_tos(), handle, fio->ad_fsp, ADOUBLE_RSRC);
3151                 if (ad == NULL) {
3152                         tevent_req_error(req, ENOMEM);
3153                         return tevent_req_post(req, ev);
3154                 }
3155                 fsp = fio->ad_fsp;
3156         }
3157
3158         subreq = SMB_VFS_NEXT_FSYNC_SEND(state, ev, handle, fsp);
3159         if (tevent_req_nomem(req, subreq)) {
3160                 return tevent_req_post(req, ev);
3161         }
3162         tevent_req_set_callback(subreq, fruit_fsync_done, req);
3163         return req;
3164 }
3165
3166 static void fruit_fsync_done(struct tevent_req *subreq)
3167 {
3168         struct tevent_req *req = tevent_req_callback_data(
3169                 subreq, struct tevent_req);
3170         struct fruit_fsync_state *state = tevent_req_data(
3171                 req, struct fruit_fsync_state);
3172
3173         state->ret = SMB_VFS_FSYNC_RECV(subreq, &state->vfs_aio_state);
3174         TALLOC_FREE(subreq);
3175         if (state->ret != 0) {
3176                 tevent_req_error(req, errno);
3177                 return;
3178         }
3179         tevent_req_done(req);
3180 }
3181
3182 static int fruit_fsync_recv(struct tevent_req *req,
3183                                         struct vfs_aio_state *vfs_aio_state)
3184 {
3185         struct fruit_fsync_state *state = tevent_req_data(
3186                 req, struct fruit_fsync_state);
3187         int retval = -1;
3188
3189         if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
3190                 tevent_req_received(req);
3191                 return -1;
3192         }
3193
3194         *vfs_aio_state = state->vfs_aio_state;
3195         retval = state->ret;
3196         tevent_req_received(req);
3197         return retval;
3198 }
3199
3200 /**
3201  * Helper to stat/lstat the base file of an smb_fname.
3202  */
3203 static int fruit_stat_base(vfs_handle_struct *handle,
3204                            struct smb_filename *smb_fname,
3205                            bool follow_links)
3206 {
3207         char *tmp_stream_name;
3208         int rc;
3209
3210         tmp_stream_name = smb_fname->stream_name;
3211         smb_fname->stream_name = NULL;
3212         if (follow_links) {
3213                 rc = SMB_VFS_NEXT_STAT(handle, smb_fname);
3214         } else {
3215                 rc = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
3216         }
3217         smb_fname->stream_name = tmp_stream_name;
3218
3219         DBG_DEBUG("fruit_stat_base [%s] dev [%ju] ino [%ju]\n",
3220                   smb_fname->base_name,
3221                   (uintmax_t)smb_fname->st.st_ex_dev,
3222                   (uintmax_t)smb_fname->st.st_ex_ino);
3223         return rc;
3224 }
3225
3226 static int fruit_stat_meta_stream(vfs_handle_struct *handle,
3227                                   struct smb_filename *smb_fname,
3228                                   bool follow_links)
3229 {
3230         int ret;
3231         ino_t ino;
3232
3233         ret = fruit_stat_base(handle, smb_fname, false);
3234         if (ret != 0) {
3235                 return -1;
3236         }
3237
3238         ino = hash_inode(&smb_fname->st, smb_fname->stream_name);
3239
3240         if (follow_links) {
3241                 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
3242         } else {
3243                 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
3244         }
3245
3246         smb_fname->st.st_ex_ino = ino;
3247
3248         return ret;
3249 }
3250
3251 static int fruit_stat_meta_netatalk(vfs_handle_struct *handle,
3252                                     struct smb_filename *smb_fname,
3253                                     bool follow_links)
3254 {
3255         struct adouble *ad = NULL;
3256
3257         /* Populate the stat struct with info from the base file. */
3258         if (fruit_stat_base(handle, smb_fname, follow_links) == -1) {
3259                 return -1;
3260         }
3261
3262         ad = ad_get_meta_fsp(talloc_tos(), handle, smb_fname);
3263         if (ad == NULL) {
3264                 DBG_INFO("fruit_stat_meta %s: %s\n",
3265                          smb_fname_str_dbg(smb_fname), strerror(errno));
3266                 errno = ENOENT;
3267                 return -1;
3268         }
3269         TALLOC_FREE(ad);
3270
3271         smb_fname->st.st_ex_size = AFP_INFO_SIZE;
3272         smb_fname->st.st_ex_ino = hash_inode(&smb_fname->st,
3273                                               smb_fname->stream_name);
3274         return 0;
3275 }
3276
3277 static int fruit_stat_meta(vfs_handle_struct *handle,
3278                            struct smb_filename *smb_fname,
3279                            bool follow_links)
3280 {
3281         struct fruit_config_data *config = NULL;
3282         int ret;
3283
3284         SMB_VFS_HANDLE_GET_DATA(handle, config,
3285                                 struct fruit_config_data, return -1);
3286
3287         switch (config->meta) {
3288         case FRUIT_META_STREAM:
3289                 ret = fruit_stat_meta_stream(handle, smb_fname, follow_links);
3290                 break;
3291
3292         case FRUIT_META_NETATALK:
3293                 ret = fruit_stat_meta_netatalk(handle, smb_fname, follow_links);
3294                 break;
3295
3296         default:
3297                 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
3298                 return -1;
3299         }
3300
3301         return ret;
3302 }
3303
3304 static int fruit_stat_rsrc_netatalk(vfs_handle_struct *handle,
3305                                     struct smb_filename *smb_fname,
3306                                     bool follow_links)
3307 {
3308         struct adouble *ad = NULL;
3309         int ret;
3310
3311         ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_RSRC);
3312         if (ad == NULL) {
3313                 errno = ENOENT;
3314                 return -1;
3315         }
3316
3317         /* Populate the stat struct with info from the base file. */
3318         ret = fruit_stat_base(handle, smb_fname, follow_links);
3319         if (ret != 0) {
3320                 TALLOC_FREE(ad);
3321                 return -1;
3322         }
3323
3324         smb_fname->st.st_ex_size = ad_getentrylen(ad, ADEID_RFORK);
3325         smb_fname->st.st_ex_ino = hash_inode(&smb_fname->st,
3326                                               smb_fname->stream_name);
3327         TALLOC_FREE(ad);
3328         return 0;
3329 }
3330
3331 static int fruit_stat_rsrc_stream(vfs_handle_struct *handle,
3332                                   struct smb_filename *smb_fname,
3333                                   bool follow_links)
3334 {
3335         int ret;
3336
3337         if (follow_links) {
3338                 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
3339         } else {
3340                 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
3341         }
3342
3343         return ret;
3344 }
3345
3346 static int fruit_stat_rsrc_xattr(vfs_handle_struct *handle,
3347                                  struct smb_filename *smb_fname,
3348                                  bool follow_links)
3349 {
3350 #ifdef HAVE_ATTROPEN
3351         int ret;
3352         int fd = -1;
3353
3354         /* Populate the stat struct with info from the base file. */
3355         ret = fruit_stat_base(handle, smb_fname, follow_links);
3356         if (ret != 0) {
3357                 return -1;
3358         }
3359
3360         fd = attropen(smb_fname->base_name,
3361                       AFPRESOURCE_EA_NETATALK,
3362                       O_RDONLY);
3363         if (fd == -1) {
3364                 return 0;
3365         }
3366
3367         ret = sys_fstat(fd, &smb_fname->st, false);
3368         if (ret != 0) {
3369                 close(fd);
3370                 DBG_ERR("fstat [%s:%s] failed\n", smb_fname->base_name,
3371                         AFPRESOURCE_EA_NETATALK);
3372                 return -1;
3373         }
3374         close(fd);
3375         fd = -1;
3376
3377         smb_fname->st.st_ex_ino = hash_inode(&smb_fname->st,
3378                                              smb_fname->stream_name);
3379
3380         return ret;
3381
3382 #else
3383         errno = ENOSYS;
3384         return -1;
3385 #endif
3386 }
3387
3388 static int fruit_stat_rsrc(vfs_handle_struct *handle,
3389                            struct smb_filename *smb_fname,
3390                            bool follow_links)
3391 {
3392         struct fruit_config_data *config = NULL;
3393         int ret;
3394
3395         DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
3396
3397         SMB_VFS_HANDLE_GET_DATA(handle, config,
3398                                 struct fruit_config_data, return -1);
3399
3400         switch (config->rsrc) {
3401         case FRUIT_RSRC_STREAM:
3402                 ret = fruit_stat_rsrc_stream(handle, smb_fname, follow_links);
3403                 break;
3404
3405         case FRUIT_RSRC_XATTR:
3406                 ret = fruit_stat_rsrc_xattr(handle, smb_fname, follow_links);
3407                 break;
3408
3409         case FRUIT_RSRC_ADFILE:
3410                 ret = fruit_stat_rsrc_netatalk(handle, smb_fname, follow_links);
3411                 break;
3412
3413         default:
3414                 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
3415                 return -1;
3416         }
3417
3418         return ret;
3419 }
3420
3421 static int fruit_stat(vfs_handle_struct *handle,
3422                       struct smb_filename *smb_fname)
3423 {
3424         int rc = -1;
3425
3426         DEBUG(10, ("fruit_stat called for %s\n",
3427                    smb_fname_str_dbg(smb_fname)));
3428
3429         if (!is_named_stream(smb_fname)) {
3430                 rc = SMB_VFS_NEXT_STAT(handle, smb_fname);
3431                 if (rc == 0) {
3432                         update_btime(handle, smb_fname);
3433                 }
3434                 return rc;
3435         }
3436
3437         /*
3438          * Note if lp_posix_paths() is true, we can never
3439          * get here as is_ntfs_stream_smb_fname() is
3440          * always false. So we never need worry about
3441          * not following links here.
3442          */
3443
3444         if (is_afpinfo_stream(smb_fname->stream_name)) {
3445                 rc = fruit_stat_meta(handle, smb_fname, true);
3446         } else if (is_afpresource_stream(smb_fname->stream_name)) {
3447                 rc = fruit_stat_rsrc(handle, smb_fname, true);
3448         } else {
3449                 return SMB_VFS_NEXT_STAT(handle, smb_fname);
3450         }
3451
3452         if (rc == 0) {
3453                 update_btime(handle, smb_fname);
3454                 smb_fname->st.st_ex_mode &= ~S_IFMT;
3455                 smb_fname->st.st_ex_mode |= S_IFREG;
3456                 smb_fname->st.st_ex_blocks =
3457                         smb_fname->st.st_ex_size / STAT_ST_BLOCKSIZE + 1;
3458         }
3459         return rc;
3460 }
3461
3462 static int fruit_lstat(vfs_handle_struct *handle,
3463                        struct smb_filename *smb_fname)
3464 {
3465         int rc = -1;
3466
3467         DEBUG(10, ("fruit_lstat called for %s\n",
3468                    smb_fname_str_dbg(smb_fname)));
3469
3470         if (!is_named_stream(smb_fname)) {
3471                 rc = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
3472                 if (rc == 0) {
3473                         update_btime(handle, smb_fname);
3474                 }
3475                 return rc;
3476         }
3477
3478         if (is_afpinfo_stream(smb_fname->stream_name)) {
3479                 rc = fruit_stat_meta(handle, smb_fname, false);
3480         } else if (is_afpresource_stream(smb_fname->stream_name)) {
3481                 rc = fruit_stat_rsrc(handle, smb_fname, false);
3482         } else {
3483                 return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
3484         }
3485
3486         if (rc == 0) {
3487                 update_btime(handle, smb_fname);
3488                 smb_fname->st.st_ex_mode &= ~S_IFMT;
3489                 smb_fname->st.st_ex_mode |= S_IFREG;
3490                 smb_fname->st.st_ex_blocks =
3491                         smb_fname->st.st_ex_size / STAT_ST_BLOCKSIZE + 1;
3492         }
3493         return rc;
3494 }
3495
3496 static int fruit_fstat_meta_stream(vfs_handle_struct *handle,
3497                                    files_struct *fsp,
3498                                    SMB_STRUCT_STAT *sbuf)
3499 {
3500         struct fio *fio = fruit_get_complete_fio(handle, fsp);
3501         struct smb_filename smb_fname;
3502         ino_t ino;
3503         int ret;
3504
3505         if (fio == NULL) {
3506                 return -1;
3507         }
3508
3509         if (fio->fake_fd) {
3510                 ret = fruit_stat_base(handle, fsp->base_fsp->fsp_name, false);
3511                 if (ret != 0) {
3512                         return -1;
3513                 }
3514
3515                 *sbuf = fsp->base_fsp->fsp_name->st;
3516                 sbuf->st_ex_size = AFP_INFO_SIZE;
3517                 sbuf->st_ex_ino = hash_inode(sbuf, fsp->fsp_name->stream_name);
3518                 return 0;
3519         }
3520
3521         smb_fname = (struct smb_filename) {
3522                 .base_name = fsp->fsp_name->base_name,
3523                 .twrp = fsp->fsp_name->twrp,
3524         };
3525
3526         ret = fruit_stat_base(handle, &smb_fname, false);
3527         if (ret != 0) {
3528                 return -1;
3529         }
3530         *sbuf = smb_fname.st;
3531
3532         ino = hash_inode(sbuf, fsp->fsp_name->stream_name);
3533
3534         ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
3535         if (ret != 0) {
3536                 return -1;
3537         }
3538
3539         sbuf->st_ex_ino = ino;
3540         return 0;
3541 }
3542
3543 static int fruit_fstat_meta_netatalk(vfs_handle_struct *handle,
3544                                      files_struct *fsp,
3545                                      SMB_STRUCT_STAT *sbuf)
3546 {
3547         int ret;
3548
3549         ret = fruit_stat_base(handle, fsp->base_fsp->fsp_name, false);
3550         if (ret != 0) {
3551                 return -1;
3552         }
3553
3554         *sbuf = fsp->base_fsp->fsp_name->st;
3555         sbuf->st_ex_size = AFP_INFO_SIZE;
3556         sbuf->st_ex_ino = hash_inode(sbuf, fsp->fsp_name->stream_name);
3557
3558         return 0;
3559 }
3560
3561 static int fruit_fstat_meta(vfs_handle_struct *handle,
3562                             files_struct *fsp,
3563                             SMB_STRUCT_STAT *sbuf,
3564                             struct fio *fio)
3565 {
3566         int ret;
3567
3568         DBG_DEBUG("Path [%s]\n", fsp_str_dbg(fsp));
3569
3570         switch (fio->config->meta) {
3571         case FRUIT_META_STREAM:
3572                 ret = fruit_fstat_meta_stream(handle, fsp, sbuf);
3573                 break;
3574
3575         case FRUIT_META_NETATALK:
3576                 ret = fruit_fstat_meta_netatalk(handle, fsp, sbuf);
3577                 break;
3578
3579         default:
3580                 DBG_ERR("Unexpected meta config [%d]\n", fio->config->meta);
3581                 return -1;
3582         }
3583
3584         DBG_DEBUG("Path [%s] ret [%d]\n", fsp_str_dbg(fsp), ret);
3585         return ret;
3586 }
3587
3588 static int fruit_fstat_rsrc_xattr(vfs_handle_struct *handle,
3589                                   files_struct *fsp,
3590                                   SMB_STRUCT_STAT *sbuf)
3591 {
3592         return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
3593 }
3594
3595 static int fruit_fstat_rsrc_stream(vfs_handle_struct *handle,
3596                                    files_struct *fsp,
3597                                    SMB_STRUCT_STAT *sbuf)
3598 {
3599         return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
3600 }
3601
3602 static int fruit_fstat_rsrc_adouble(vfs_handle_struct *handle,
3603                                     files_struct *fsp,
3604                                     SMB_STRUCT_STAT *sbuf)
3605 {
3606         struct fio *fio = fruit_get_complete_fio(handle, fsp);
3607         struct adouble *ad = NULL;
3608         int ret;
3609
3610         if (fio == NULL || fio->ad_fsp == NULL) {
3611                 DBG_ERR("fio/ad_fsp=NULL for [%s]\n", fsp_str_dbg(fsp));
3612                 errno = EBADF;
3613                 return -1;
3614         }
3615
3616         /* Populate the stat struct with info from the base file. */
3617         ret = fruit_stat_base(handle, fsp->base_fsp->fsp_name, false);
3618         if (ret == -1) {
3619                 return -1;
3620         }
3621
3622         ad = ad_fget(talloc_tos(), handle, fio->ad_fsp, ADOUBLE_RSRC);
3623         if (ad == NULL) {
3624                 DBG_ERR("ad_fget [%s] failed [%s]\n",
3625                         fsp_str_dbg(fio->ad_fsp), strerror(errno));
3626                 return -1;
3627         }
3628
3629         *sbuf = fsp->base_fsp->fsp_name->st;
3630         sbuf->st_ex_size = ad_getentrylen(ad, ADEID_RFORK);
3631         sbuf->st_ex_ino = hash_inode(sbuf, fsp->fsp_name->stream_name);
3632
3633         TALLOC_FREE(ad);
3634         return 0;
3635 }
3636
3637 static int fruit_fstat_rsrc(vfs_handle_struct *handle, files_struct *fsp,
3638                             SMB_STRUCT_STAT *sbuf, struct fio *fio)
3639 {
3640         int ret;
3641
3642         switch (fio->config->rsrc) {
3643         case FRUIT_RSRC_STREAM:
3644                 ret = fruit_fstat_rsrc_stream(handle, fsp, sbuf);
3645                 break;
3646
3647         case FRUIT_RSRC_ADFILE:
3648                 ret = fruit_fstat_rsrc_adouble(handle, fsp, sbuf);
3649                 break;
3650
3651         case FRUIT_RSRC_XATTR:
3652                 ret = fruit_fstat_rsrc_xattr(handle, fsp, sbuf);
3653                 break;
3654
3655         default:
3656                 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
3657                 return -1;
3658         }
3659
3660         return ret;
3661 }
3662
3663 static int fruit_fstat(vfs_handle_struct *handle, files_struct *fsp,
3664                        SMB_STRUCT_STAT *sbuf)
3665 {
3666         struct fio *fio = fruit_get_complete_fio(handle, fsp);
3667         int rc;
3668
3669         if (fio == NULL) {
3670                 return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
3671         }
3672
3673         DBG_DEBUG("Path [%s]\n", fsp_str_dbg(fsp));
3674
3675         if (fio->type == ADOUBLE_META) {
3676                 rc = fruit_fstat_meta(handle, fsp, sbuf, fio);
3677         } else {
3678                 rc = fruit_fstat_rsrc(handle, fsp, sbuf, fio);
3679         }
3680
3681         if (rc == 0) {
3682                 sbuf->st_ex_mode &= ~S_IFMT;
3683                 sbuf->st_ex_mode |= S_IFREG;
3684                 sbuf->st_ex_blocks = sbuf->st_ex_size / STAT_ST_BLOCKSIZE + 1;
3685         }
3686
3687         DBG_DEBUG("Path [%s] rc [%d] size [%"PRIdMAX"]\n",
3688                   fsp_str_dbg(fsp), rc, (intmax_t)sbuf->st_ex_size);
3689         return rc;
3690 }
3691
3692 static NTSTATUS delete_invalid_meta_stream(
3693         vfs_handle_struct *handle,
3694         const struct smb_filename *smb_fname,
3695         TALLOC_CTX *mem_ctx,
3696         unsigned int *pnum_streams,
3697         struct stream_struct **pstreams,
3698         off_t size)
3699 {
3700         struct smb_filename *sname = NULL;
3701         NTSTATUS status;
3702         int ret;
3703         bool ok;
3704
3705         ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams, AFPINFO_STREAM);
3706         if (!ok) {
3707                 return NT_STATUS_INTERNAL_ERROR;
3708         }
3709
3710         if (size == 0) {
3711                 return NT_STATUS_OK;
3712         }
3713
3714         status = synthetic_pathref(talloc_tos(),
3715                                    handle->conn->cwd_fsp,
3716                                    smb_fname->base_name,
3717                                    AFPINFO_STREAM_NAME,
3718                                    NULL,
3719                                    smb_fname->twrp,
3720                                    0,
3721                                    &sname);
3722         if (!NT_STATUS_IS_OK(status)) {
3723                 return NT_STATUS_NO_MEMORY;
3724         }
3725
3726         ret = SMB_VFS_NEXT_UNLINKAT(handle,
3727                         handle->conn->cwd_fsp,
3728                         sname,
3729                         0);
3730         if (ret != 0) {
3731                 DBG_ERR("Removing [%s] failed\n", smb_fname_str_dbg(sname));
3732                 TALLOC_FREE(sname);
3733                 return map_nt_error_from_unix(errno);
3734         }
3735
3736         TALLOC_FREE(sname);
3737         return NT_STATUS_OK;
3738 }
3739
3740 static NTSTATUS fruit_streaminfo_meta_stream(
3741         vfs_handle_struct *handle,
3742         struct files_struct *fsp,
3743         const struct smb_filename *smb_fname,
3744         TALLOC_CTX *mem_ctx,
3745         unsigned int *pnum_streams,
3746         struct stream_struct **pstreams)
3747 {
3748         struct stream_struct *stream = *pstreams;
3749         unsigned int num_streams = *pnum_streams;
3750         int i;
3751
3752         for (i = 0; i < num_streams; i++) {
3753                 if (strequal_m(stream[i].name, AFPINFO_STREAM)) {
3754                         break;
3755                 }
3756         }
3757
3758         if (i == num_streams) {
3759                 return NT_STATUS_OK;
3760         }
3761
3762         if (stream[i].size != AFP_INFO_SIZE) {
3763                 DBG_ERR("Removing invalid AFPINFO_STREAM size [%jd] from [%s]\n",
3764                         (intmax_t)stream[i].size, smb_fname_str_dbg(smb_fname));
3765
3766                 return delete_invalid_meta_stream(handle,
3767                                                   smb_fname,
3768                                                   mem_ctx,
3769                                                   pnum_streams,
3770                                                   pstreams,
3771                                                   stream[i].size);
3772         }
3773
3774
3775         return NT_STATUS_OK;
3776 }
3777
3778 static NTSTATUS fruit_streaminfo_meta_netatalk(
3779         vfs_handle_struct *handle,
3780         struct files_struct *fsp,
3781         const struct smb_filename *smb_fname,
3782         TALLOC_CTX *mem_ctx,
3783         unsigned int *pnum_streams,
3784         struct stream_struct **pstreams)
3785 {
3786         struct stream_struct *stream = *pstreams;
3787         unsigned int num_streams = *pnum_streams;
3788         struct adouble *ad = NULL;
3789         bool is_fi_empty;
3790         int i;
3791         bool ok;
3792
3793         /* Remove the Netatalk xattr from the list */
3794         ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams,
3795                               ":" NETATALK_META_XATTR ":$DATA");
3796         if (!ok) {
3797                 return NT_STATUS_NO_MEMORY;
3798         }
3799
3800         /*
3801          * Check if there's a AFPINFO_STREAM from the VFS streams
3802          * backend and if yes, remove it from the list
3803          */
3804         for (i = 0; i < num_streams; i++) {
3805                 if (strequal_m(stream[i].name, AFPINFO_STREAM)) {
3806                         break;
3807                 }
3808         }
3809
3810         if (i < num_streams) {
3811                 DBG_WARNING("Unexpected AFPINFO_STREAM on [%s]\n",
3812                             smb_fname_str_dbg(smb_fname));
3813
3814                 ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams,
3815                                       AFPINFO_STREAM);
3816                 if (!ok) {
3817                         return NT_STATUS_INTERNAL_ERROR;
3818                 }
3819         }
3820
3821         ad = ad_get_meta_fsp(talloc_tos(), handle, smb_fname);
3822         if (ad == NULL) {
3823                 return NT_STATUS_OK;
3824         }
3825
3826         is_fi_empty = ad_empty_finderinfo(ad);
3827         TALLOC_FREE(ad);
3828
3829         if (is_fi_empty) {
3830                 return NT_STATUS_OK;
3831         }
3832
3833         ok = add_fruit_stream(mem_ctx, pnum_streams, pstreams,
3834                               AFPINFO_STREAM_NAME, AFP_INFO_SIZE,
3835                               smb_roundup(handle->conn, AFP_INFO_SIZE));
3836         if (!ok) {
3837                 return NT_STATUS_NO_MEMORY;
3838         }
3839
3840         return NT_STATUS_OK;
3841 }
3842
3843 static NTSTATUS fruit_streaminfo_meta(vfs_handle_struct *handle,
3844                                       struct files_struct *fsp,
3845                                       const struct smb_filename *smb_fname,
3846                                       TALLOC_CTX *mem_ctx,
3847                                       unsigned int *pnum_streams,
3848                                       struct stream_struct **pstreams)
3849 {
3850         struct fruit_config_data *config = NULL;
3851         NTSTATUS status;
3852
3853         SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
3854                                 return NT_STATUS_INTERNAL_ERROR);
3855
3856         switch (config->meta) {
3857         case FRUIT_META_NETATALK:
3858                 status = fruit_streaminfo_meta_netatalk(handle, fsp, smb_fname,
3859                                                         mem_ctx, pnum_streams,
3860                                                         pstreams);
3861                 break;
3862
3863         case FRUIT_META_STREAM:
3864                 status = fruit_streaminfo_meta_stream(handle, fsp, smb_fname,
3865                                                       mem_ctx, pnum_streams,
3866                                                       pstreams);
3867                 break;
3868
3869         default:
3870                 return NT_STATUS_INTERNAL_ERROR;
3871         }
3872
3873         return status;
3874 }
3875
3876 static NTSTATUS fruit_streaminfo_rsrc_stream(
3877         vfs_handle_struct *handle,
3878         struct files_struct *fsp,
3879         const struct smb_filename *smb_fname,
3880         TALLOC_CTX *mem_ctx,
3881         unsigned int *pnum_streams,
3882         struct stream_struct **pstreams)
3883 {
3884         bool ok;
3885
3886         ok = filter_empty_rsrc_stream(pnum_streams, pstreams);
3887         if (!ok) {
3888                 DBG_ERR("Filtering resource stream failed\n");
3889                 return NT_STATUS_INTERNAL_ERROR;
3890         }
3891         return NT_STATUS_OK;
3892 }
3893
3894 static NTSTATUS fruit_streaminfo_rsrc_xattr(
3895         vfs_handle_struct *handle,
3896         struct files_struct *fsp,
3897         const struct smb_filename *smb_fname,
3898         TALLOC_CTX *mem_ctx,
3899         unsigned int *pnum_streams,
3900         struct stream_struct **pstreams)
3901 {
3902         bool ok;
3903
3904         ok = filter_empty_rsrc_stream(pnum_streams, pstreams);
3905         if (!ok) {
3906                 DBG_ERR("Filtering resource stream failed\n");
3907                 return NT_STATUS_INTERNAL_ERROR;
3908         }
3909         return NT_STATUS_OK;
3910 }
3911
3912 static NTSTATUS fruit_streaminfo_rsrc_adouble(
3913         vfs_handle_struct *handle,
3914         struct files_struct *fsp,
3915         const struct smb_filename *smb_fname,
3916         TALLOC_CTX *mem_ctx,
3917         unsigned int *pnum_streams,
3918         struct stream_struct **pstreams)
3919 {
3920         struct stream_struct *stream = *pstreams;
3921         unsigned int num_streams = *pnum_streams;
3922         struct adouble *ad = NULL;
3923         bool ok;
3924         size_t rlen;
3925         int i;
3926
3927         /*
3928          * Check if there's a AFPRESOURCE_STREAM from the VFS streams backend
3929          * and if yes, remove it from the list
3930          */
3931         for (i = 0; i < num_streams; i++) {
3932                 if (strequal_m(stream[i].name, AFPRESOURCE_STREAM)) {
3933                         break;
3934                 }
3935         }
3936
3937         if (i < num_streams) {
3938                 DBG_WARNING("Unexpected AFPRESOURCE_STREAM on [%s]\n",
3939                             smb_fname_str_dbg(smb_fname));
3940
3941                 ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams,
3942                                       AFPRESOURCE_STREAM);
3943                 if (!ok) {
3944                         return NT_STATUS_INTERNAL_ERROR;
3945                 }
3946         }
3947
3948         ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_RSRC);
3949         if (ad == NULL) {
3950                 return NT_STATUS_OK;
3951         }
3952
3953         rlen = ad_getentrylen(ad, ADEID_RFORK);
3954         TALLOC_FREE(ad);
3955
3956         if (rlen == 0) {
3957                 return NT_STATUS_OK;
3958         }
3959
3960         ok = add_fruit_stream(mem_ctx, pnum_streams, pstreams,
3961                               AFPRESOURCE_STREAM_NAME, rlen,
3962                               smb_roundup(handle->conn, rlen));
3963         if (!ok) {
3964                 return NT_STATUS_NO_MEMORY;
3965         }
3966
3967         return NT_STATUS_OK;
3968 }
3969
3970 static NTSTATUS fruit_streaminfo_rsrc(vfs_handle_struct *handle,
3971                                       struct files_struct *fsp,
3972                                       const struct smb_filename *smb_fname,
3973                                       TALLOC_CTX *mem_ctx,
3974                                       unsigned int *pnum_streams,
3975                                       struct stream_struct **pstreams)
3976 {
3977         struct fruit_config_data *config = NULL;
3978         NTSTATUS status;
3979
3980         if (S_ISDIR(smb_fname->st.st_ex_mode)) {
3981                 return NT_STATUS_OK;
3982         }
3983
3984         SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
3985                                 return NT_STATUS_INTERNAL_ERROR);
3986
3987         switch (config->rsrc) {
3988         case FRUIT_RSRC_STREAM:
3989                 status = fruit_streaminfo_rsrc_stream(handle, fsp, smb_fname,
3990                                                       mem_ctx, pnum_streams,
3991                                                       pstreams);
3992                 break;
3993
3994         case FRUIT_RSRC_XATTR:
3995                 status = fruit_streaminfo_rsrc_xattr(handle, fsp, smb_fname,
3996                                                      mem_ctx, pnum_streams,
3997                                                      pstreams);
3998                 break;
3999
4000         case FRUIT_RSRC_ADFILE:
4001                 status = fruit_streaminfo_rsrc_adouble(handle, fsp, smb_fname,
4002                                                        mem_ctx, pnum_streams,
4003                                                        pstreams);
4004                 break;
4005
4006         default:
4007                 return NT_STATUS_INTERNAL_ERROR;
4008         }
4009
4010         return status;
4011 }
4012
4013 static void fruit_filter_empty_streams(unsigned int *pnum_streams,
4014                                        struct stream_struct **pstreams)
4015 {
4016         unsigned num_streams = *pnum_streams;
4017         struct stream_struct *streams = *pstreams;
4018         unsigned i = 0;
4019
4020         if (!global_fruit_config.nego_aapl) {
4021                 return;
4022         }
4023
4024         while (i < num_streams) {
4025                 struct smb_filename smb_fname = (struct smb_filename) {
4026                         .stream_name = streams[i].name,
4027                 };
4028
4029                 if (is_ntfs_default_stream_smb_fname(&smb_fname)
4030                     || streams[i].size > 0)
4031                 {
4032                         i++;
4033                         continue;
4034                 }
4035
4036                 streams[i] = streams[num_streams - 1];
4037                 num_streams--;
4038         }
4039
4040         *pnum_streams = num_streams;
4041 }
4042
4043 static NTSTATUS fruit_fstreaminfo(vfs_handle_struct *handle,
4044                                  struct files_struct *fsp,
4045                                  TALLOC_CTX *mem_ctx,
4046                                  unsigned int *pnum_streams,
4047                                  struct stream_struct **pstreams)
4048 {
4049         struct fruit_config_data *config = NULL;
4050         const struct smb_filename *smb_fname = NULL;
4051         NTSTATUS status;
4052
4053         smb_fname = fsp->fsp_name;
4054
4055         SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
4056                                 return NT_STATUS_UNSUCCESSFUL);
4057
4058         DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
4059
4060         status = SMB_VFS_NEXT_FSTREAMINFO(handle, fsp, mem_ctx,
4061                                          pnum_streams, pstreams);
4062         if (!NT_STATUS_IS_OK(status)) {
4063                 return status;
4064         }
4065
4066         fruit_filter_empty_streams(pnum_streams, pstreams);
4067
4068         status = fruit_streaminfo_meta(handle, fsp, smb_fname,
4069                                        mem_ctx, pnum_streams, pstreams);
4070         if (!NT_STATUS_IS_OK(status)) {
4071                 return status;
4072         }
4073
4074         status = fruit_streaminfo_rsrc(handle, fsp, smb_fname,
4075                                        mem_ctx, pnum_streams, pstreams);
4076         if (!NT_STATUS_IS_OK(status)) {
4077                 return status;
4078         }
4079
4080         return NT_STATUS_OK;
4081 }
4082
4083 static int fruit_fntimes(vfs_handle_struct *handle,
4084                          files_struct *fsp,
4085                          struct smb_file_time *ft)
4086 {
4087         int rc = 0;
4088         struct adouble *ad = NULL;
4089         struct fruit_config_data *config = NULL;
4090
4091         SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
4092                                 return -1);
4093
4094         if ((config->meta != FRUIT_META_NETATALK) ||
4095             is_omit_timespec(&ft->create_time))
4096         {
4097                 return SMB_VFS_NEXT_FNTIMES(handle, fsp, ft);
4098         }
4099
4100         DBG_DEBUG("set btime for %s to %s", fsp_str_dbg(fsp),
4101                   time_to_asc(convert_timespec_to_time_t(ft->create_time)));
4102
4103         ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_META);
4104         if (ad == NULL) {
4105                 goto exit;
4106         }
4107
4108         ad_setdate(ad, AD_DATE_CREATE | AD_DATE_UNIX,
4109                    convert_time_t_to_uint32_t(ft->create_time.tv_sec));
4110
4111         rc = ad_fset(handle, ad, fsp);
4112
4113 exit:
4114
4115         TALLOC_FREE(ad);
4116         if (rc != 0) {
4117                 DBG_WARNING("%s\n", fsp_str_dbg(fsp));
4118                 return -1;
4119         }
4120         return SMB_VFS_NEXT_FNTIMES(handle, fsp, ft);
4121 }
4122
4123 static int fruit_fallocate(struct vfs_handle_struct *handle,
4124                            struct files_struct *fsp,
4125                            uint32_t mode,
4126                            off_t offset,
4127                            off_t len)
4128 {
4129         struct fio *fio = fruit_get_complete_fio(handle, fsp);
4130
4131         if (fio == NULL) {
4132                 return SMB_VFS_NEXT_FALLOCATE(handle, fsp, mode, offset, len);
4133         }
4134
4135         /* Let the pwrite code path handle it. */
4136         errno = ENOSYS;
4137         return -1;
4138 }
4139
4140 static int fruit_ftruncate_rsrc_xattr(struct vfs_handle_struct *handle,
4141                                       struct files_struct *fsp,
4142                                       off_t offset)
4143 {
4144 #ifdef HAVE_ATTROPEN
4145         return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
4146 #endif
4147         return 0;
4148 }
4149
4150 static int fruit_ftruncate_rsrc_adouble(struct vfs_handle_struct *handle,
4151                                         struct files_struct *fsp,
4152                                         off_t offset)
4153 {
4154         struct fio *fio = fruit_get_complete_fio(handle, fsp);
4155         int rc;
4156         struct adouble *ad = NULL;
4157         off_t ad_off;
4158
4159         if (fio == NULL || fio->ad_fsp == NULL) {
4160                 DBG_ERR("fio/ad_fsp=NULL for [%s]\n", fsp_str_dbg(fsp));
4161                 errno = EBADF;
4162                 return -1;
4163         }
4164
4165         ad = ad_fget(talloc_tos(), handle, fio->ad_fsp, ADOUBLE_RSRC);
4166         if (ad == NULL) {
4167                 DBG_ERR("ad_fget [%s] failed [%s]\n",
4168                         fsp_str_dbg(fio->ad_fsp), strerror(errno));
4169                 return -1;
4170         }
4171
4172         ad_off = ad_getentryoff(ad, ADEID_RFORK);
4173
4174         rc = SMB_VFS_NEXT_FTRUNCATE(handle, fio->ad_fsp, offset + ad_off);
4175         if (rc != 0) {
4176                 TALLOC_FREE(ad);
4177                 return -1;
4178         }
4179
4180         ad_setentrylen(ad, ADEID_RFORK, offset);
4181
4182         rc = ad_fset(handle, ad, fio->ad_fsp);
4183         if (rc != 0) {
4184                 DBG_ERR("ad_fset [%s] failed [%s]\n",
4185                         fsp_str_dbg(fio->ad_fsp), strerror(errno));
4186                 TALLOC_FREE(ad);
4187                 return -1;
4188         }
4189
4190         TALLOC_FREE(ad);
4191         return 0;
4192 }
4193
4194 static int fruit_ftruncate_rsrc_stream(struct vfs_handle_struct *handle,
4195                                        struct files_struct *fsp,
4196                                        off_t offset)
4197 {
4198         return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
4199 }
4200
4201 static int fruit_ftruncate_rsrc(struct vfs_handle_struct *handle,
4202                                 struct files_struct *fsp,
4203                                 off_t offset)
4204 {
4205         struct fio *fio = fruit_get_complete_fio(handle, fsp);
4206         int ret;
4207
4208         if (fio == NULL) {
4209                 DBG_ERR("Failed to fetch fsp extension\n");
4210                 return -1;
4211         }
4212
4213         switch (fio->config->rsrc) {
4214         case FRUIT_RSRC_XATTR:
4215                 ret = fruit_ftruncate_rsrc_xattr(handle, fsp, offset);
4216                 break;
4217
4218         case FRUIT_RSRC_ADFILE:
4219                 ret = fruit_ftruncate_rsrc_adouble(handle, fsp, offset);
4220                 break;
4221
4222         case FRUIT_RSRC_STREAM:
4223                 ret = fruit_ftruncate_rsrc_stream(handle, fsp, offset);
4224                 break;
4225
4226         default:
4227                 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
4228                 return -1;
4229         }
4230
4231
4232         return ret;
4233 }
4234
4235 static int fruit_ftruncate_meta(struct vfs_handle_struct *handle,
4236                                 struct files_struct *fsp,
4237                                 off_t offset)
4238 {
4239         if (offset > 60) {
4240                 DBG_WARNING("ftruncate %s to %jd\n",
4241                             fsp_str_dbg(fsp), (intmax_t)offset);
4242                 /* OS X returns NT_STATUS_ALLOTTED_SPACE_EXCEEDED  */
4243                 errno = EOVERFLOW;
4244                 return -1;
4245         }
4246
4247         /* OS X returns success but does nothing  */
4248         DBG_INFO("ignoring ftruncate %s to %jd\n",
4249                  fsp_str_dbg(fsp), (intmax_t)offset);
4250         return 0;
4251 }
4252
4253 static int fruit_ftruncate(struct vfs_handle_struct *handle,
4254                            struct files_struct *fsp,
4255                            off_t offset)
4256 {
4257         struct fio *fio = fruit_get_complete_fio(handle, fsp);
4258         int ret;
4259
4260         DBG_DEBUG("Path [%s] offset [%"PRIdMAX"]\n", fsp_str_dbg(fsp),
4261                   (intmax_t)offset);
4262
4263         if (fio == NULL) {
4264                 return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
4265         }
4266
4267         if (fio->type == ADOUBLE_META) {
4268                 ret = fruit_ftruncate_meta(handle, fsp, offset);
4269         } else {
4270                 ret = fruit_ftruncate_rsrc(handle, fsp, offset);
4271         }
4272
4273         DBG_DEBUG("Path [%s] result [%d]\n", fsp_str_dbg(fsp), ret);
4274         return ret;
4275 }
4276
4277 static NTSTATUS fruit_create_file(vfs_handle_struct *handle,
4278                                   struct smb_request *req,
4279                                   struct files_struct *dirfsp,
4280                                   struct smb_filename *smb_fname,
4281                                   uint32_t access_mask,
4282                                   uint32_t share_access,
4283                                   uint32_t create_disposition,
4284                                   uint32_t create_options,
4285                                   uint32_t file_attributes,
4286                                   uint32_t oplock_request,
4287                                   const struct smb2_lease *lease,
4288                                   uint64_t allocation_size,
4289                                   uint32_t private_flags,
4290                                   struct security_descriptor *sd,
4291                                   struct ea_list *ea_list,
4292                                   files_struct **result,
4293                                   int *pinfo,
4294                                   const struct smb2_create_blobs *in_context_blobs,
4295                                   struct smb2_create_blobs *out_context_blobs)
4296 {
4297         NTSTATUS status;
4298         struct fruit_config_data *config = NULL;
4299         files_struct *fsp = NULL;
4300         bool internal_open = (oplock_request & INTERNAL_OPEN_ONLY);
4301         int ret;
4302
4303         status = check_aapl(handle, req, in_context_blobs, out_context_blobs);
4304         if (!NT_STATUS_IS_OK(status)) {
4305                 goto fail;
4306         }
4307
4308         SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
4309                                 return NT_STATUS_UNSUCCESSFUL);
4310
4311         if (is_apple_stream(smb_fname->stream_name) &&
4312             !internal_open &&
4313             config->convert_adouble)
4314         {
4315                 uint32_t conv_flags  = 0;
4316
4317                 if (config->wipe_intentionally_left_blank_rfork) {
4318                         conv_flags |= AD_CONV_WIPE_BLANK;
4319                 }
4320                 if (config->delete_empty_adfiles) {
4321                         conv_flags |= AD_CONV_DELETE;
4322                 }
4323
4324                 ret = ad_convert(handle,
4325                                  smb_fname,
4326                                  macos_string_replace_map,
4327                                  conv_flags);
4328                 if (ret != 0) {
4329                         DBG_ERR("ad_convert(\"%s\") failed\n",
4330                                 smb_fname_str_dbg(smb_fname));
4331                 }
4332         }
4333
4334         status = SMB_VFS_NEXT_CREATE_FILE(
4335                 handle, req, dirfsp, smb_fname,
4336                 access_mask, share_access,
4337                 create_disposition, create_options,
4338                 file_attributes, oplock_request,
4339                 lease,
4340                 allocation_size, private_flags,
4341                 sd, ea_list, result,
4342                 pinfo, in_context_blobs, out_context_blobs);
4343         if (!NT_STATUS_IS_OK(status)) {
4344                 return status;
4345         }
4346
4347         fsp = *result;
4348
4349         if (global_fruit_config.nego_aapl) {
4350                 if (config->posix_rename && fsp->fsp_flags.is_directory) {
4351                         /*
4352                          * Enable POSIX directory rename behaviour
4353                          */
4354                         fsp->posix_flags |= FSP_POSIX_FLAGS_RENAME;
4355                 }
4356         }
4357
4358         /*
4359          * If this is a plain open for existing files, opening an 0
4360          * byte size resource fork MUST fail with
4361          * NT_STATUS_OBJECT_NAME_NOT_FOUND.
4362          *
4363          * Cf the vfs_fruit torture tests in test_rfork_create().
4364          */
4365         if (global_fruit_config.nego_aapl &&
4366             create_disposition == FILE_OPEN &&
4367             smb_fname->st.st_ex_size == 0 &&
4368             is_named_stream(smb_fname))
4369         {
4370                 status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
4371                 goto fail;
4372         }
4373
4374         if (is_named_stream(smb_fname) || fsp->fsp_flags.is_directory) {
4375                 return status;
4376         }
4377
4378         if ((config->locking == FRUIT_LOCKING_NETATALK) &&
4379             (fsp->op != NULL) &&
4380             !fsp->fsp_flags.is_pathref)
4381         {
4382                 status = fruit_check_access(
4383                         handle, *result,
4384                         access_mask,
4385                         share_access);
4386                 if (!NT_STATUS_IS_OK(status)) {
4387                         goto fail;
4388                 }
4389         }
4390
4391         return status;
4392
4393 fail:
4394         DEBUG(10, ("fruit_create_file: %s\n", nt_errstr(status)));
4395
4396         if (fsp) {
4397                 close_file_free(req, &fsp, ERROR_CLOSE);
4398                 *result = NULL;
4399         }
4400
4401         return status;
4402 }
4403
4404 static NTSTATUS fruit_freaddir_attr(struct vfs_handle_struct *handle,
4405                                     struct files_struct *fsp,
4406                                     TALLOC_CTX *mem_ctx,
4407                                     struct readdir_attr_data **pattr_data)
4408 {
4409         struct fruit_config_data *config = NULL;
4410         struct readdir_attr_data *attr_data;
4411         uint32_t conv_flags  = 0;
4412         NTSTATUS status;
4413         int ret;
4414
4415         SMB_VFS_HANDLE_GET_DATA(handle, config,
4416                                 struct fruit_config_data,
4417                                 return NT_STATUS_UNSUCCESSFUL);
4418
4419         if (!global_fruit_config.nego_aapl) {
4420                 return SMB_VFS_NEXT_FREADDIR_ATTR(handle,
4421                                                   fsp,
4422                                                   mem_ctx,
4423                                                   pattr_data);
4424         }
4425
4426         DBG_DEBUG("Path [%s]\n", fsp_str_dbg(fsp));
4427
4428         if (config->convert_adouble) {
4429                 if (config->wipe_intentionally_left_blank_rfork) {
4430                         conv_flags |= AD_CONV_WIPE_BLANK;
4431                 }
4432                 if (config->delete_empty_adfiles) {
4433                         conv_flags |= AD_CONV_DELETE;
4434                 }
4435
4436                 ret = ad_convert(handle,
4437                                  fsp->fsp_name,
4438                                  macos_string_replace_map,
4439                                  conv_flags);
4440                 if (ret != 0) {
4441                         DBG_ERR("ad_convert(\"%s\") failed\n",
4442                                 fsp_str_dbg(fsp));
4443                 }
4444         }
4445
4446         *pattr_data = talloc_zero(mem_ctx, struct readdir_attr_data);
4447         if (*pattr_data == NULL) {
4448                 return NT_STATUS_NO_MEMORY;
4449         }
4450         attr_data = *pattr_data;
4451         attr_data->type = RDATTR_AAPL;
4452
4453         /*
4454          * Mac metadata: compressed FinderInfo, resource fork length
4455          * and creation date
4456          */
4457         status = readdir_attr_macmeta(handle, fsp->fsp_name, attr_data);
4458         if (!NT_STATUS_IS_OK(status)) {
4459                 /*
4460                  * Error handling is tricky: if we return failure from
4461                  * this function, the corresponding directory entry
4462                  * will to be passed to the client, so we really just
4463                  * want to error out on fatal errors.
4464                  */
4465                 if  (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
4466                         goto fail;
4467                 }
4468         }
4469
4470         /*
4471          * UNIX mode
4472          */
4473         if (config->unix_info_enabled) {
4474                 attr_data->attr_data.aapl.unix_mode =
4475                         fsp->fsp_name->st.st_ex_mode;
4476         }
4477
4478         /*
4479          * max_access
4480          */
4481         if (!config->readdir_attr_max_access) {
4482                 attr_data->attr_data.aapl.max_access = FILE_GENERIC_ALL;
4483         } else {
4484                 status = smbd_calculate_access_mask_fsp(fsp->conn->cwd_fsp,
4485                         fsp,
4486                         false,
4487                         SEC_FLAG_MAXIMUM_ALLOWED,
4488                         &attr_data->attr_data.aapl.max_access);
4489                 if (!NT_STATUS_IS_OK(status)) {
4490                         goto fail;
4491                 }
4492         }
4493
4494         return NT_STATUS_OK;
4495
4496 fail:
4497         DBG_WARNING("Path [%s], error: %s\n", fsp_str_dbg(fsp),
4498                    nt_errstr(status));
4499         TALLOC_FREE(*pattr_data);
4500         return status;
4501 }
4502
4503 static NTSTATUS fruit_fget_nt_acl(vfs_handle_struct *handle,
4504                                   files_struct *fsp,
4505                                   uint32_t security_info,
4506                                   TALLOC_CTX *mem_ctx,
4507                                   struct security_descriptor **ppdesc)
4508 {
4509         NTSTATUS status;
4510         struct security_ace ace;
4511         struct dom_sid sid;
4512         struct fruit_config_data *config;
4513
4514         SMB_VFS_HANDLE_GET_DATA(handle, config,
4515                                 struct fruit_config_data,
4516                                 return NT_STATUS_UNSUCCESSFUL);
4517
4518         status = SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info,
4519                                           mem_ctx, ppdesc);
4520         if (!NT_STATUS_IS_OK(status)) {
4521                 return status;
4522         }
4523
4524         /*
4525          * Add MS NFS style ACEs with uid, gid and mode
4526          */
4527         if (!global_fruit_config.nego_aapl) {
4528                 return NT_STATUS_OK;
4529         }
4530         if (!config->unix_info_enabled) {
4531                 return NT_STATUS_OK;
4532         }
4533
4534         /* First remove any existing ACE's with NFS style mode/uid/gid SIDs. */
4535         status = remove_virtual_nfs_aces(*ppdesc);
4536         if (!NT_STATUS_IS_OK(status)) {
4537                 DBG_WARNING("failed to remove MS NFS style ACEs\n");
4538                 return status;
4539         }
4540
4541         /* MS NFS style mode */
4542         sid_compose(&sid, &global_sid_Unix_NFS_Mode, fsp->fsp_name->st.st_ex_mode);
4543         init_sec_ace(&ace, &sid, SEC_ACE_TYPE_ACCESS_DENIED, 0, 0);
4544         status = security_descriptor_dacl_add(*ppdesc, &ace);
4545         if (!NT_STATUS_IS_OK(status)) {
4546                 DEBUG(1,("failed to add MS NFS style ACE\n"));
4547                 return status;
4548         }
4549
4550         /* MS NFS style uid */
4551         sid_compose(&sid, &global_sid_Unix_NFS_Users, fsp->fsp_name->st.st_ex_uid);
4552         init_sec_ace(&ace, &sid, SEC_ACE_TYPE_ACCESS_DENIED, 0, 0);
4553         status = security_descriptor_dacl_add(*ppdesc, &ace);
4554         if (!NT_STATUS_IS_OK(status)) {
4555                 DEBUG(1,("failed to add MS NFS style ACE\n"));
4556                 return status;
4557         }
4558
4559         /* MS NFS style gid */
4560         sid_compose(&sid, &global_sid_Unix_NFS_Groups, fsp->fsp_name->st.st_ex_gid);
4561         init_sec_ace(&ace, &sid, SEC_ACE_TYPE_ACCESS_DENIED, 0, 0);
4562         status = security_descriptor_dacl_add(*ppdesc, &ace);
4563         if (!NT_STATUS_IS_OK(status)) {
4564                 DEBUG(1,("failed to add MS NFS style ACE\n"));
4565                 return status;
4566         }
4567
4568         return NT_STATUS_OK;
4569 }
4570
4571 static NTSTATUS fruit_fset_nt_acl(vfs_handle_struct *handle,
4572                                   files_struct *fsp,
4573                                   uint32_t security_info_sent,
4574                                   const struct security_descriptor *orig_psd)
4575 {
4576         NTSTATUS status;
4577         bool do_chmod;
4578         mode_t ms_nfs_mode = 0;
4579         int result;
4580         struct security_descriptor *psd = NULL;
4581         uint32_t orig_num_aces = 0;
4582
4583         if (orig_psd->dacl != NULL) {
4584                 orig_num_aces = orig_psd->dacl->num_aces;
4585         }
4586
4587         psd = security_descriptor_copy(talloc_tos(), orig_psd);
4588         if (psd == NULL) {
4589                 return NT_STATUS_NO_MEMORY;
4590         }
4591
4592         DBG_DEBUG("fruit_fset_nt_acl: %s\n", fsp_str_dbg(fsp));
4593
4594         status = check_ms_nfs(handle, fsp, psd, &ms_nfs_mode, &do_chmod);
4595         if (!NT_STATUS_IS_OK(status)) {
4596                 DEBUG(1, ("fruit_fset_nt_acl: check_ms_nfs failed%s\n", fsp_str_dbg(fsp)));
4597                 TALLOC_FREE(psd);
4598                 return status;
4599         }
4600
4601         /*
4602          * If only ms_nfs ACE entries were sent, ensure we set the DACL
4603          * sent/present flags correctly now we've removed them.
4604          */
4605
4606         if (orig_num_aces != 0) {
4607                 /*
4608                  * Are there any ACE's left ?
4609                  */
4610                 if (psd->dacl->num_aces == 0) {
4611                         /* No - clear the DACL sent/present flags. */
4612                         security_info_sent &= ~SECINFO_DACL;
4613                         psd->type &= ~SEC_DESC_DACL_PRESENT;
4614                 }
4615         }
4616
4617         status = SMB_VFS_NEXT_FSET_NT_ACL(handle, fsp, security_info_sent, psd);
4618         if (!NT_STATUS_IS_OK(status)) {
4619                 DEBUG(1, ("fruit_fset_nt_acl: SMB_VFS_NEXT_FSET_NT_ACL failed%s\n", fsp_str_dbg(fsp)));
4620                 TALLOC_FREE(psd);
4621                 return status;
4622         }
4623
4624         if (do_chmod) {
4625                 result = SMB_VFS_FCHMOD(fsp, ms_nfs_mode);
4626                 if (result != 0) {
4627                         DBG_WARNING("%s, result: %d, %04o error %s\n",
4628                                 fsp_str_dbg(fsp),
4629                                 result,
4630                                 (unsigned)ms_nfs_mode,
4631                                 strerror(errno));
4632                         status = map_nt_error_from_unix(errno);
4633                         TALLOC_FREE(psd);
4634                         return status;
4635                 }
4636         }
4637
4638         TALLOC_FREE(psd);
4639         return NT_STATUS_OK;
4640 }
4641
4642 static struct vfs_offload_ctx *fruit_offload_ctx;
4643
4644 struct fruit_offload_read_state {
4645         struct vfs_handle_struct *handle;
4646         struct tevent_context *ev;
4647         files_struct *fsp;
4648         uint32_t fsctl;
4649         uint32_t flags;
4650         uint64_t xferlen;
4651         DATA_BLOB token;
4652 };
4653
4654 static void fruit_offload_read_done(struct tevent_req *subreq);
4655
4656 static struct tevent_req *fruit_offload_read_send(
4657         TALLOC_CTX *mem_ctx,
4658         struct tevent_context *ev,
4659         struct vfs_handle_struct *handle,
4660         files_struct *fsp,
4661         uint32_t fsctl,
4662         uint32_t ttl,
4663         off_t offset,
4664         size_t to_copy)
4665 {
4666         struct tevent_req *req = NULL;
4667         struct tevent_req *subreq = NULL;
4668         struct fruit_offload_read_state *state = NULL;
4669
4670         req = tevent_req_create(mem_ctx, &state,
4671                                 struct fruit_offload_read_state);
4672         if (req == NULL) {
4673                 return NULL;
4674         }
4675         *state = (struct fruit_offload_read_state) {
4676                 .handle = handle,
4677                 .ev = ev,
4678                 .fsp = fsp,
4679                 .fsctl = fsctl,
4680         };
4681
4682         subreq = SMB_VFS_NEXT_OFFLOAD_READ_SEND(mem_ctx, ev, handle, fsp,
4683                                                 fsctl, ttl, offset, to_copy);
4684         if (tevent_req_nomem(subreq, req)) {
4685                 return tevent_req_post(req, ev);
4686         }
4687         tevent_req_set_callback(subreq, fruit_offload_read_done, req);
4688         return req;
4689 }
4690
4691 static void fruit_offload_read_done(struct tevent_req *subreq)
4692 {
4693         struct tevent_req *req = tevent_req_callback_data(
4694                 subreq, struct tevent_req);
4695         struct fruit_offload_read_state *state = tevent_req_data(
4696                 req, struct fruit_offload_read_state);
4697         NTSTATUS status;
4698
4699         status = SMB_VFS_NEXT_OFFLOAD_READ_RECV(subreq,
4700                                                 state->handle,
4701                                                 state,
4702                                                 &state->flags,
4703                                                 &state->xferlen,
4704                                                 &state->token);
4705         TALLOC_FREE(subreq);
4706         if (tevent_req_nterror(req, status)) {
4707                 return;
4708         }
4709
4710         if (state->fsctl != FSCTL_SRV_REQUEST_RESUME_KEY) {
4711                 tevent_req_done(req);
4712                 return;
4713         }
4714
4715         status = vfs_offload_token_ctx_init(state->fsp->conn->sconn->client,
4716                                             &fruit_offload_ctx);
4717         if (tevent_req_nterror(req, status)) {
4718                 return;
4719         }
4720
4721         status = vfs_offload_token_db_store_fsp(fruit_offload_ctx,
4722                                                 state->fsp,
4723                                                 &state->token);
4724         if (tevent_req_nterror(req, status)) {
4725                 return;
4726         }
4727
4728         tevent_req_done(req);
4729         return;
4730 }
4731
4732 static NTSTATUS fruit_offload_read_recv(struct tevent_req *req,
4733                                         struct vfs_handle_struct *handle,
4734                                         TALLOC_CTX *mem_ctx,
4735                                         uint32_t *flags,
4736                                         uint64_t *xferlen,
4737                                         DATA_BLOB *token)
4738 {
4739         struct fruit_offload_read_state *state = tevent_req_data(
4740                 req, struct fruit_offload_read_state);
4741         NTSTATUS status;
4742
4743         if (tevent_req_is_nterror(req, &status)) {
4744                 tevent_req_received(req);
4745                 return status;
4746         }
4747
4748         *flags = state->flags;
4749         *xferlen = state->xferlen;
4750         token->length = state->token.length;
4751         token->data = talloc_move(mem_ctx, &state->token.data);
4752
4753         tevent_req_received(req);
4754         return NT_STATUS_OK;
4755 }
4756
4757 struct fruit_offload_write_state {
4758         struct vfs_handle_struct *handle;
4759         off_t copied;
4760         struct files_struct *src_fsp;
4761         struct files_struct *dst_fsp;
4762         bool is_copyfile;
4763 };
4764
4765 static void fruit_offload_write_done(struct tevent_req *subreq);
4766 static struct tevent_req *fruit_offload_write_send(struct vfs_handle_struct *handle,
4767                                                 TALLOC_CTX *mem_ctx,
4768                                                 struct tevent_context *ev,
4769                                                 uint32_t fsctl,
4770                                                 DATA_BLOB *token,
4771                                                 off_t transfer_offset,
4772                                                 struct files_struct *dest_fsp,
4773                                                 off_t dest_off,
4774                                                 off_t num)
4775 {
4776         struct tevent_req *req, *subreq;
4777         struct fruit_offload_write_state *state;
4778         NTSTATUS status;
4779         struct fruit_config_data *config;
4780         off_t src_off = transfer_offset;
4781         files_struct *src_fsp = NULL;
4782         off_t to_copy = num;
4783         bool copyfile_enabled = false;
4784
4785         DEBUG(10,("soff: %ju, doff: %ju, len: %ju\n",
4786                   (uintmax_t)src_off, (uintmax_t)dest_off, (uintmax_t)num));
4787
4788         SMB_VFS_HANDLE_GET_DATA(handle, config,
4789                                 struct fruit_config_data,
4790                                 return NULL);
4791
4792         req = tevent_req_create(mem_ctx, &state,
4793                                 struct fruit_offload_write_state);
4794         if (req == NULL) {
4795                 return NULL;
4796         }
4797         state->handle = handle;
4798         state->dst_fsp = dest_fsp;
4799
4800         switch (fsctl) {
4801         case FSCTL_SRV_COPYCHUNK:
4802         case FSCTL_SRV_COPYCHUNK_WRITE:
4803                 copyfile_enabled = config->copyfile_enabled;
4804                 break;
4805         default:
4806                 break;
4807         }
4808
4809         /*
4810          * Check if this a OS X copyfile style copychunk request with
4811          * a requested chunk count of 0 that was translated to a
4812          * offload_write_send VFS call overloading the parameters src_off
4813          * = dest_off = num = 0.
4814          */
4815         if (copyfile_enabled && num == 0 && src_off == 0 && dest_off == 0) {
4816                 status = vfs_offload_token_db_fetch_fsp(
4817                         fruit_offload_ctx, token, &src_fsp);
4818                 if (tevent_req_nterror(req, status)) {
4819                         return tevent_req_post(req, ev);
4820                 }
4821                 state->src_fsp = src_fsp;
4822
4823                 status = vfs_stat_fsp(src_fsp);
4824                 if (tevent_req_nterror(req, status)) {
4825                         return tevent_req_post(req, ev);
4826                 }
4827
4828                 to_copy = src_fsp->fsp_name->st.st_ex_size;
4829                 state->is_copyfile = true;
4830         }
4831
4832         subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle,
4833                                               mem_ctx,
4834                                               ev,
4835                                               fsctl,
4836                                               token,
4837                                               transfer_offset,
4838                                               dest_fsp,
4839                                               dest_off,
4840                                               to_copy);
4841         if (tevent_req_nomem(subreq, req)) {
4842                 return tevent_req_post(req, ev);
4843         }
4844
4845         tevent_req_set_callback(subreq, fruit_offload_write_done, req);
4846         return req;
4847 }
4848
4849 static void fruit_offload_write_done(struct tevent_req *subreq)
4850 {
4851         struct tevent_req *req = tevent_req_callback_data(
4852                 subreq, struct tevent_req);
4853         struct fruit_offload_write_state *state = tevent_req_data(
4854                 req, struct fruit_offload_write_state);
4855         NTSTATUS status;
4856         unsigned int num_streams = 0;
4857         struct stream_struct *streams = NULL;
4858         unsigned int i;
4859         struct smb_filename *src_fname_tmp = NULL;
4860         struct smb_filename *dst_fname_tmp = NULL;
4861
4862         status = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(state->handle,
4863                                               subreq,
4864                                               &state->copied);
4865         TALLOC_FREE(subreq);
4866         if (tevent_req_nterror(req, status)) {
4867                 return;
4868         }
4869
4870         if (!state->is_copyfile) {
4871                 tevent_req_done(req);
4872                 return;
4873         }
4874
4875         /*
4876          * Now copy all remaining streams. We know the share supports
4877          * streams, because we're in vfs_fruit. We don't do this async
4878          * because streams are few and small.
4879          */
4880         status = vfs_fstreaminfo(state->src_fsp,
4881                                 req, &num_streams, &streams);
4882         if (tevent_req_nterror(req, status)) {
4883                 return;
4884         }
4885
4886         if (num_streams == 1) {
4887                 /* There is always one stream, ::$DATA. */
4888                 tevent_req_done(req);
4889                 return;
4890         }
4891
4892         for (i = 0; i < num_streams; i++) {
4893                 DEBUG(10, ("%s: stream: '%s'/%zu\n",
4894                           __func__, streams[i].name, (size_t)streams[i].size));
4895
4896                 src_fname_tmp = synthetic_smb_fname(
4897                         req,
4898                         state->src_fsp->fsp_name->base_name,
4899                         streams[i].name,
4900                         NULL,
4901                         state->src_fsp->fsp_name->twrp,
4902                         state->src_fsp->fsp_name->flags);
4903                 if (tevent_req_nomem(src_fname_tmp, req)) {
4904                         return;
4905                 }
4906
4907                 if (is_ntfs_default_stream_smb_fname(src_fname_tmp)) {
4908                         TALLOC_FREE(src_fname_tmp);
4909                         continue;
4910                 }
4911
4912                 dst_fname_tmp = synthetic_smb_fname(
4913                         req,
4914                         state->dst_fsp->fsp_name->base_name,
4915                         streams[i].name,
4916                         NULL,
4917                         state->dst_fsp->fsp_name->twrp,
4918                         state->dst_fsp->fsp_name->flags);
4919                 if (tevent_req_nomem(dst_fname_tmp, req)) {
4920                         TALLOC_FREE(src_fname_tmp);
4921                         return;
4922                 }
4923
4924                 status = copy_file(req,
4925                                    state->handle->conn,
4926                                    src_fname_tmp,
4927                                    dst_fname_tmp,
4928                                    FILE_CREATE);
4929                 if (!NT_STATUS_IS_OK(status)) {
4930                         DEBUG(1, ("%s: copy %s to %s failed: %s\n", __func__,
4931                                   smb_fname_str_dbg(src_fname_tmp),
4932                                   smb_fname_str_dbg(dst_fname_tmp),
4933                                   nt_errstr(status)));
4934                         TALLOC_FREE(src_fname_tmp);
4935                         TALLOC_FREE(dst_fname_tmp);
4936                         tevent_req_nterror(req, status);
4937                         return;
4938                 }
4939
4940                 TALLOC_FREE(src_fname_tmp);
4941                 TALLOC_FREE(dst_fname_tmp);
4942         }
4943
4944         TALLOC_FREE(streams);
4945         TALLOC_FREE(src_fname_tmp);
4946         TALLOC_FREE(dst_fname_tmp);
4947         tevent_req_done(req);
4948 }
4949
4950 static NTSTATUS fruit_offload_write_recv(struct vfs_handle_struct *handle,
4951                                       struct tevent_req *req,
4952                                       off_t *copied)
4953 {
4954         struct fruit_offload_write_state *state = tevent_req_data(
4955                 req, struct fruit_offload_write_state);
4956         NTSTATUS status;
4957
4958         if (tevent_req_is_nterror(req, &status)) {
4959                 DEBUG(1, ("server side copy chunk failed: %s\n",
4960                           nt_errstr(status)));
4961                 *copied = 0;
4962                 tevent_req_received(req);
4963                 return status;
4964         }
4965
4966         *copied = state->copied;
4967         tevent_req_received(req);
4968
4969         return NT_STATUS_OK;
4970 }
4971
4972 static char *fruit_get_bandsize_line(char **lines, int numlines)
4973 {
4974         static regex_t re;
4975         static bool re_initialized = false;
4976         int i;
4977         int ret;
4978
4979         if (!re_initialized) {
4980                 ret = regcomp(&re, "^[[:blank:]]*<key>band-size</key>$", 0);
4981                 if (ret != 0) {
4982                         return NULL;
4983                 }
4984                 re_initialized = true;
4985         }
4986
4987         for (i = 0; i < numlines; i++) {
4988                 regmatch_t matches[1];
4989
4990                 ret = regexec(&re, lines[i], 1, matches, 0);
4991                 if (ret == 0) {
4992                         /*
4993                          * Check if the match was on the last line, sa we want
4994                          * the subsequent line.
4995                          */
4996                         if (i + 1 == numlines) {
4997                                 return NULL;
4998                         }
4999                         return lines[i + 1];
5000                 }
5001                 if (ret != REG_NOMATCH) {
5002                         return NULL;
5003                 }
5004         }
5005
5006         return NULL;
5007 }
5008
5009 static bool fruit_get_bandsize_from_line(char *line, size_t *_band_size)
5010 {
5011         static regex_t re;
5012         static bool re_initialized = false;
5013         regmatch_t matches[2];
5014         uint64_t band_size;
5015         int ret;
5016         bool ok;
5017
5018         if (!re_initialized) {
5019                 ret = regcomp(&re,
5020                               "^[[:blank:]]*"
5021                               "<integer>\\([[:digit:]]*\\)</integer>$",
5022                               0);
5023                 if (ret != 0) {
5024                         return false;
5025                 }
5026                 re_initialized = true;
5027         }
5028
5029         ret = regexec(&re, line, 2, matches, 0);
5030         if (ret != 0) {
5031                 DBG_ERR("regex failed [%s]\n", line);
5032                 return false;
5033         }
5034
5035         line[matches[1].rm_eo] = '\0';
5036
5037         ok = conv_str_u64(&line[matches[1].rm_so], &band_size);
5038         if (!ok) {
5039                 return false;
5040         }
5041         *_band_size = (size_t)band_size;
5042         return true;
5043 }
5044
5045 /*
5046  * This reads and parses an Info.plist from a TM sparsebundle looking for the
5047  * "band-size" key and value.
5048  */
5049 static bool fruit_get_bandsize(vfs_handle_struct *handle,
5050                                const char *dir,
5051                                size_t *band_size)
5052 {
5053 #define INFO_PLIST_MAX_SIZE 64*1024
5054         char *plist = NULL;
5055         struct smb_filename *smb_fname = NULL;
5056         files_struct *fsp = NULL;
5057         uint8_t *file_data = NULL;
5058         char **lines = NULL;
5059         char *band_size_line = NULL;
5060         size_t plist_file_size;
5061         ssize_t nread;
5062         int numlines;
5063         int ret;
5064         bool ok = false;
5065         NTSTATUS status;
5066
5067         plist = talloc_asprintf(talloc_tos(),
5068                                 "%s/%s/Info.plist",
5069                                 handle->conn->connectpath,
5070                                 dir);
5071         if (plist == NULL) {
5072                 ok = false;
5073                 goto out;
5074         }
5075
5076         smb_fname = synthetic_smb_fname(talloc_tos(),
5077                                         plist,
5078                                         NULL,
5079                                         NULL,
5080                                         0,
5081                                         0);
5082         if (smb_fname == NULL) {
5083                 ok = false;
5084                 goto out;
5085         }
5086
5087         ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
5088         if (ret != 0) {
5089                 DBG_INFO("Ignoring Sparsebundle without Info.plist [%s]\n", dir);
5090                 ok = true;
5091                 goto out;
5092         }
5093
5094         plist_file_size = smb_fname->st.st_ex_size;
5095
5096         if (plist_file_size > INFO_PLIST_MAX_SIZE) {
5097                 DBG_INFO("%s is too large, ignoring\n", plist);
5098                 ok = true;
5099                 goto out;
5100         }
5101
5102         status = SMB_VFS_NEXT_CREATE_FILE(
5103                 handle,                         /* conn */
5104                 NULL,                           /* req */
5105                 NULL,                           /* dirfsp */
5106                 smb_fname,                      /* fname */
5107                 FILE_GENERIC_READ,              /* access_mask */
5108                 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
5109                 FILE_OPEN,                      /* create_disposition */
5110                 0,                              /* create_options */
5111                 0,                              /* file_attributes */
5112                 INTERNAL_OPEN_ONLY,             /* oplock_request */
5113                 NULL,                           /* lease */
5114                 0,                              /* allocation_size */
5115                 0,                              /* private_flags */
5116                 NULL,                           /* sd */
5117                 NULL,                           /* ea_list */
5118                 &fsp,                           /* result */
5119                 NULL,                           /* psbuf */
5120                 NULL, NULL);                    /* create context */
5121         if (!NT_STATUS_IS_OK(status)) {
5122                 DBG_INFO("Opening [%s] failed [%s]\n",
5123                          smb_fname_str_dbg(smb_fname), nt_errstr(status));
5124                 ok = false;
5125                 goto out;
5126         }
5127
5128         file_data = talloc_zero_array(talloc_tos(),
5129                                       uint8_t,
5130                                       plist_file_size + 1);
5131         if (file_data == NULL) {
5132                 ok = false;
5133                 goto out;
5134         }
5135
5136         nread = SMB_VFS_NEXT_PREAD(handle, fsp, file_data, plist_file_size, 0);
5137         if (nread != plist_file_size) {
5138                 DBG_ERR("Short read on [%s]: %zu/%zd\n",
5139                         fsp_str_dbg(fsp), nread, plist_file_size);
5140                 ok = false;
5141                 goto out;
5142
5143         }
5144
5145         status = close_file_free(NULL, &fsp, NORMAL_CLOSE);
5146         if (!NT_STATUS_IS_OK(status)) {
5147                 DBG_ERR("close_file failed: %s\n", nt_errstr(status));
5148                 ok = false;
5149                 goto out;
5150         }
5151
5152         lines = file_lines_parse((char *)file_data,
5153                                  plist_file_size,
5154                                  &numlines,
5155                                  talloc_tos());
5156         if (lines == NULL) {
5157                 ok = false;
5158                 goto out;
5159         }
5160
5161         band_size_line = fruit_get_bandsize_line(lines, numlines);
5162         if (band_size_line == NULL) {
5163                 DBG_ERR("Didn't find band-size key in [%s]\n",
5164                         smb_fname_str_dbg(smb_fname));
5165                 ok = false;
5166                 goto out;
5167         }
5168
5169         ok = fruit_get_bandsize_from_line(band_size_line, band_size);
5170         if (!ok) {
5171                 DBG_ERR("fruit_get_bandsize_from_line failed\n");
5172                 goto out;
5173         }
5174
5175         DBG_DEBUG("Parsed band-size [%zu] for [%s]\n", *band_size, plist);
5176
5177 out:
5178         if (fsp != NULL) {
5179                 status = close_file_free(NULL, &fsp, NORMAL_CLOSE);
5180                 if (!NT_STATUS_IS_OK(status)) {
5181                         DBG_ERR("close_file failed: %s\n", nt_errstr(status));
5182                 }
5183         }
5184         TALLOC_FREE(plist);
5185         TALLOC_FREE(smb_fname);
5186         TALLOC_FREE(file_data);
5187         TALLOC_FREE(lines);
5188         return ok;
5189 }
5190
5191 struct fruit_disk_free_state {
5192         off_t total_size;
5193 };
5194
5195 static bool fruit_get_num_bands(vfs_handle_struct *handle,
5196                                 const char *bundle,
5197                                 size_t *_nbands)
5198 {
5199         char *path = NULL;
5200         struct smb_filename *bands_dir = NULL;
5201         struct smb_Dir *dir_hnd = NULL;
5202         const char *dname = NULL;
5203         char *talloced = NULL;
5204         size_t nbands;
5205         NTSTATUS status;
5206
5207         path = talloc_asprintf(talloc_tos(),
5208                                "%s/%s/bands",
5209                                handle->conn->connectpath,
5210                                bundle);
5211         if (path == NULL) {
5212                 return false;
5213         }
5214
5215         bands_dir = synthetic_smb_fname(talloc_tos(),
5216                                         path,
5217                                         NULL,
5218                                         NULL,
5219                                         0,
5220                                         0);
5221         TALLOC_FREE(path);
5222         if (bands_dir == NULL) {
5223                 return false;
5224         }
5225
5226         status = OpenDir(talloc_tos(),
5227                          handle->conn,
5228                          bands_dir,
5229                          NULL,
5230                          0,
5231                          &dir_hnd);
5232         if (!NT_STATUS_IS_OK(status)) {
5233                 TALLOC_FREE(bands_dir);
5234                 errno = map_errno_from_nt_status(status);
5235                 return false;
5236         }
5237
5238         nbands = 0;
5239
5240         while ((dname = ReadDirName(dir_hnd, &talloced)) != NULL) {
5241                 if (ISDOT(dname) || ISDOTDOT(dname)) {
5242                         continue;
5243                 }
5244                 nbands++;
5245         }
5246         TALLOC_FREE(dir_hnd);
5247
5248         DBG_DEBUG("%zu bands in [%s]\n", nbands, smb_fname_str_dbg(bands_dir));
5249
5250         TALLOC_FREE(bands_dir);
5251
5252         *_nbands = nbands;
5253         return true;
5254 }
5255
5256 static bool fruit_tmsize_do_dirent(vfs_handle_struct *handle,
5257                                    struct fruit_disk_free_state *state,
5258                                    const char *name)
5259 {
5260         bool ok;
5261         char *p = NULL;
5262         size_t sparsebundle_strlen = strlen("sparsebundle");
5263         size_t bandsize = 0;
5264         size_t nbands;
5265         off_t tm_size;
5266
5267         p = strstr(name, "sparsebundle");
5268         if (p == NULL) {
5269                 return true;
5270         }
5271
5272         if (p[sparsebundle_strlen] != '\0') {
5273                 return true;
5274         }
5275
5276         DBG_DEBUG("Processing sparsebundle [%s]\n", name);
5277
5278         ok = fruit_get_bandsize(handle, name, &bandsize);
5279         if (!ok) {
5280                 /*
5281                  * Beware of race conditions: this may be an uninitialized
5282                  * Info.plist that a client is just creating. We don't want let
5283                  * this to trigger complete failure.
5284                  */
5285                 DBG_ERR("Processing sparsebundle [%s] failed\n", name);
5286                 return true;
5287         }
5288
5289         ok = fruit_get_num_bands(handle, name, &nbands);
5290         if (!ok) {
5291                 /*
5292                  * Beware of race conditions: this may be a backup sparsebundle
5293                  * in an early stage lacking a bands subdirectory. We don't want
5294                  * let this to trigger complete failure.
5295                  */
5296                 DBG_ERR("Processing sparsebundle [%s] failed\n", name);
5297                 return true;
5298         }
5299
5300         /*
5301          * Arithmetic on 32-bit systems may cause overflow, depending on
5302          * size_t precision. First we check its unlikely, then we
5303          * force the precision into target off_t, then we check that
5304          * the total did not overflow either.
5305          */
5306         if (bandsize > SIZE_MAX/nbands) {
5307                 DBG_ERR("tmsize potential overflow: bandsize [%zu] nbands [%zu]\n",
5308                         bandsize, nbands);
5309                 return false;
5310         }
5311         tm_size = (off_t)bandsize * (off_t)nbands;
5312
5313         if (state->total_size + tm_size < state->total_size) {
5314                 DBG_ERR("tm total size overflow: bandsize [%zu] nbands [%zu]\n",
5315                         bandsize, nbands);
5316                 return false;
5317         }
5318
5319         state->total_size += tm_size;
5320
5321         DBG_DEBUG("[%s] tm_size [%jd] total_size [%jd]\n",
5322                   name, (intmax_t)tm_size, (intmax_t)state->total_size);
5323
5324         return true;
5325 }
5326
5327 /**
5328  * Calculate used size of a TimeMachine volume
5329  *
5330  * This assumes that the volume is used only for TimeMachine.
5331  *
5332  * - readdir(basedir of share), then
5333  * - for every element that matches regex "^\(.*\)\.sparsebundle$" :
5334  * - parse "\1.sparsebundle/Info.plist" and read the band-size XML key
5335  * - count band files in "\1.sparsebundle/bands/"
5336  * - calculate used size of all bands: band_count * band_size
5337  **/
5338 static uint64_t fruit_disk_free(vfs_handle_struct *handle,
5339                                 const struct smb_filename *smb_fname,
5340                                 uint64_t *_bsize,
5341                                 uint64_t *_dfree,
5342                                 uint64_t *_dsize)
5343 {
5344         struct fruit_config_data *config = NULL;
5345         struct fruit_disk_free_state state = {0};
5346         struct smb_Dir *dir_hnd = NULL;
5347         const char *dname = NULL;
5348         char *talloced = NULL;
5349         uint64_t dfree;
5350         uint64_t dsize;
5351         bool ok;
5352         NTSTATUS status;
5353
5354         SMB_VFS_HANDLE_GET_DATA(handle, config,
5355                                 struct fruit_config_data,
5356                                 return UINT64_MAX);
5357
5358         if (!config->time_machine ||
5359             config->time_machine_max_size == 0)
5360         {
5361                 return SMB_VFS_NEXT_DISK_FREE(handle,
5362                                               smb_fname,
5363                                               _bsize,
5364                                               _dfree,
5365                                               _dsize);
5366         }
5367
5368         status = OpenDir(talloc_tos(),
5369                          handle->conn,
5370                          smb_fname,
5371                          NULL,
5372                          0,
5373                          &dir_hnd);
5374         if (!NT_STATUS_IS_OK(status)) {
5375                 errno = map_errno_from_nt_status(status);
5376                 return UINT64_MAX;
5377         }
5378
5379         while ((dname = ReadDirName(dir_hnd, &talloced)) != NULL) {
5380                 ok = fruit_tmsize_do_dirent(handle, &state, dname);
5381                 if (!ok) {
5382                         TALLOC_FREE(talloced);
5383                         TALLOC_FREE(dir_hnd);
5384                         return UINT64_MAX;
5385                 }
5386                 TALLOC_FREE(talloced);
5387         }
5388
5389         TALLOC_FREE(dir_hnd);
5390
5391         dsize = config->time_machine_max_size / 512;
5392         dfree = dsize - (state.total_size / 512);
5393         if (dfree > dsize) {
5394                 dfree = 0;
5395         }
5396
5397         *_bsize = 512;
5398         *_dsize = dsize;
5399         *_dfree = dfree;
5400         return dfree / 2;
5401 }
5402
5403 static uint64_t fruit_fs_file_id(struct vfs_handle_struct *handle,
5404                                  const SMB_STRUCT_STAT *psbuf)
5405 {
5406         struct fruit_config_data *config = NULL;
5407
5408         SMB_VFS_HANDLE_GET_DATA(handle, config,
5409                                 struct fruit_config_data,
5410                                 return 0);
5411
5412         if (global_fruit_config.nego_aapl &&
5413             config->aapl_zero_file_id)
5414         {
5415                 return 0;
5416         }
5417
5418         return SMB_VFS_NEXT_FS_FILE_ID(handle, psbuf);
5419 }
5420
5421 static struct vfs_fn_pointers vfs_fruit_fns = {
5422         .connect_fn = fruit_connect,
5423         .disk_free_fn = fruit_disk_free,
5424
5425         /* File operations */
5426         .fchmod_fn = fruit_fchmod,
5427         .unlinkat_fn = fruit_unlinkat,
5428         .renameat_fn = fruit_renameat,
5429         .openat_fn = fruit_openat,
5430         .close_fn = fruit_close,
5431         .pread_fn = fruit_pread,
5432         .pwrite_fn = fruit_pwrite,
5433         .pread_send_fn = fruit_pread_send,
5434         .pread_recv_fn = fruit_pread_recv,
5435         .pwrite_send_fn = fruit_pwrite_send,
5436         .pwrite_recv_fn = fruit_pwrite_recv,
5437         .fsync_send_fn = fruit_fsync_send,
5438         .fsync_recv_fn = fruit_fsync_recv,
5439         .stat_fn = fruit_stat,
5440         .lstat_fn = fruit_lstat,
5441         .fstat_fn = fruit_fstat,
5442         .fstreaminfo_fn = fruit_fstreaminfo,
5443         .fntimes_fn = fruit_fntimes,
5444         .ftruncate_fn = fruit_ftruncate,
5445         .fallocate_fn = fruit_fallocate,
5446         .create_file_fn = fruit_create_file,
5447         .freaddir_attr_fn = fruit_freaddir_attr,
5448         .offload_read_send_fn = fruit_offload_read_send,
5449         .offload_read_recv_fn = fruit_offload_read_recv,
5450         .offload_write_send_fn = fruit_offload_write_send,
5451         .offload_write_recv_fn = fruit_offload_write_recv,
5452         .fs_file_id_fn = fruit_fs_file_id,
5453
5454         /* NT ACL operations */
5455         .fget_nt_acl_fn = fruit_fget_nt_acl,
5456         .fset_nt_acl_fn = fruit_fset_nt_acl,
5457 };
5458
5459 static_decl_vfs;
5460 NTSTATUS vfs_fruit_init(TALLOC_CTX *ctx)
5461 {
5462         NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fruit",
5463                                         &vfs_fruit_fns);
5464         if (!NT_STATUS_IS_OK(ret)) {
5465                 return ret;
5466         }
5467
5468         vfs_fruit_debug_level = debug_add_class("fruit");
5469         if (vfs_fruit_debug_level == -1) {
5470                 vfs_fruit_debug_level = DBGC_VFS;
5471                 DEBUG(0, ("%s: Couldn't register custom debugging class!\n",
5472                           "vfs_fruit_init"));
5473         } else {
5474                 DEBUG(10, ("%s: Debug class number of '%s': %d\n",
5475                            "vfs_fruit_init","fruit",vfs_fruit_debug_level));
5476         }
5477
5478         return ret;
5479 }