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 "../lib/crypto/md5.h"
  26 #include "system/shmem.h"
  27 #include "locking/proto.h"
  28 #include "smbd/globals.h"
  29 #include "messages.h"
  30 #include "libcli/security/security.h"
  31 #include "../libcli/smb/smb2_create_ctx.h"
  32 #include "lib/util/sys_rw.h"
  33 #include "lib/util/tevent_ntstatus.h"
  34 #include "lib/util/tevent_unix.h"
  35 #include "offload_token.h"
  36 #include "string_replace.h"
  37
  38 /*
  39  * Enhanced OS X and Netatalk compatibility
  40  * ========================================
  41  *
  42  * This modules takes advantage of vfs_streams_xattr and
  43  * vfs_catia. VFS modules vfs_fruit and vfs_streams_xattr must be
  44  * loaded in the correct order:
  45  *
  46  *   vfs modules = catia fruit streams_xattr
  47  *
  48  * The module intercepts the OS X special streams "AFP_AfpInfo" and
  49  * "AFP_Resource" and handles them in a special way. All other named
  50  * streams are deferred to vfs_streams_xattr.
  51  *
  52  * The OS X client maps all NTFS illegal characters to the Unicode
  53  * private range. This module optionally stores the charcters using
  54  * their native ASCII encoding using vfs_catia. If you're not enabling
  55  * this feature, you can skip catia from vfs modules.
  56  *
  57  * Finally, open modes are optionally checked against Netatalk AFP
  58  * share modes.
  59  *
  60  * The "AFP_AfpInfo" named stream is a binary blob containing OS X
  61  * extended metadata for files and directories. This module optionally
  62  * reads and stores this metadata in a way compatible with Netatalk 3
  63  * which stores the metadata in an EA "org.netatalk.metadata". Cf
  64  * source3/include/MacExtensions.h for a description of the binary
  65  * blobs content.
  66  *
  67  * The "AFP_Resource" named stream may be arbitrarily large, thus it
  68  * can't be stored in an xattr on most filesystem. ZFS on Solaris is
  69  * the only available filesystem where xattrs can be of any size and
  70  * the OS supports using the file APIs for xattrs.
  71  *
  72  * The AFP_Resource stream is stored in an AppleDouble file prepending
  73  * "._" to the filename. On Solaris with ZFS the stream is optionally
  74  * stored in an EA "org.netatalk.resource".
  75  *
  76  *
  77  * Extended Attributes
  78  * ===================
  79  *
  80  * The OS X SMB client sends xattrs as ADS too. For xattr interop with
  81  * other protocols you may want to adjust the xattr names the VFS
  82  * module vfs_streams_xattr uses for storing ADS's. This defaults to
  83  * user.DosStream.ADS_NAME:$DATA and can be changed by specifying
  84  * these module parameters:
  85  *
  86  *   streams_xattr:prefix = user.
  87  *   streams_xattr:store_stream_type = false
  88  *
  89  *
  90  * TODO
  91  * ====
  92  *
  93  * - log diagnostic if any needed VFS module is not loaded
  94  *   (eg with lp_vfs_objects())
  95  * - add tests
  96  */
  97
  98 static int vfs_fruit_debug_level = DBGC_VFS;
  99
 100 static struct global_fruit_config {
 101         bool nego_aapl; /* client negotiated AAPL */
 102
 103 } global_fruit_config;
 104
 105 #undef DBGC_CLASS
 106 #define DBGC_CLASS vfs_fruit_debug_level
 107
 108 #define FRUIT_PARAM_TYPE_NAME "fruit"
 109 #define ADOUBLE_NAME_PREFIX "._"
 110
 111 #define NETATALK_META_XATTR "org.netatalk.Metadata"
 112 #define NETATALK_RSRC_XATTR "org.netatalk.ResourceFork"
 113
 114 #if defined(HAVE_ATTROPEN)
 115 #define AFPINFO_EA_NETATALK NETATALK_META_XATTR
 116 #define AFPRESOURCE_EA_NETATALK NETATALK_RSRC_XATTR
 117 #else
 118 #define AFPINFO_EA_NETATALK "user." NETATALK_META_XATTR
 119 #define AFPRESOURCE_EA_NETATALK "user." NETATALK_RSRC_XATTR
 120 #endif
 121
 122 enum apple_fork {APPLE_FORK_DATA, APPLE_FORK_RSRC};
 123
 124 enum fruit_rsrc {FRUIT_RSRC_STREAM, FRUIT_RSRC_ADFILE, FRUIT_RSRC_XATTR};
 125 enum fruit_meta {FRUIT_META_STREAM, FRUIT_META_NETATALK};
 126 enum fruit_locking {FRUIT_LOCKING_NETATALK, FRUIT_LOCKING_NONE};
 127 enum fruit_encoding {FRUIT_ENC_NATIVE, FRUIT_ENC_PRIVATE};
 128
 129 struct fruit_config_data {
 130         enum fruit_rsrc rsrc;
 131         enum fruit_meta meta;
 132         enum fruit_locking locking;
 133         enum fruit_encoding encoding;
 134         bool use_aapl;          /* config from smb.conf */
 135         bool use_copyfile;
 136         bool readdir_attr_enabled;
 137         bool unix_info_enabled;
 138         bool copyfile_enabled;
 139         bool veto_appledouble;
 140         bool posix_rename;
 141         bool aapl_zero_file_id;
 142         const char *model;
 143         bool time_machine;
 144         off_t time_machine_max_size;
 145
 146         /*
 147          * Additional options, all enabled by default,
 148          * possibly useful for analyzing performance. The associated
 149          * operations with each of them may be expensive, so having
 150          * the chance to disable them individually gives a chance
 151          * tweaking the setup for the particular usecase.
 152          */
 153         bool readdir_attr_rsize;
 154         bool readdir_attr_finder_info;
 155         bool readdir_attr_max_access;
 156 };
 157
 158 static const struct enum_list fruit_rsrc[] = {
 159         {FRUIT_RSRC_STREAM, "stream"}, /* pass on to vfs_streams_xattr */
 160         {FRUIT_RSRC_ADFILE, "file"}, /* ._ AppleDouble file */
 161         {FRUIT_RSRC_XATTR, "xattr"}, /* Netatalk compatible xattr (ZFS only) */
 162         { -1, NULL}
 163 };
 164
 165 static const struct enum_list fruit_meta[] = {
 166         {FRUIT_META_STREAM, "stream"}, /* pass on to vfs_streams_xattr */
 167         {FRUIT_META_NETATALK, "netatalk"}, /* Netatalk compatible xattr */
 168         { -1, NULL}
 169 };
 170
 171 static const struct enum_list fruit_locking[] = {
 172         {FRUIT_LOCKING_NETATALK, "netatalk"}, /* synchronize locks with Netatalk */
 173         {FRUIT_LOCKING_NONE, "none"},
 174         { -1, NULL}
 175 };
 176
 177 static const struct enum_list fruit_encoding[] = {
 178         {FRUIT_ENC_NATIVE, "native"}, /* map unicode private chars to ASCII */
 179         {FRUIT_ENC_PRIVATE, "private"}, /* keep unicode private chars */
 180         { -1, NULL}
 181 };
 182
 183 static const char *fruit_catia_maps =
 184         "0x01:0xf001,0x02:0xf002,0x03:0xf003,0x04:0xf004,"
 185         "0x05:0xf005,0x06:0xf006,0x07:0xf007,0x08:0xf008,"
 186         "0x09:0xf009,0x0a:0xf00a,0x0b:0xf00b,0x0c:0xf00c,"
 187         "0x0d:0xf00d,0x0e:0xf00e,0x0f:0xf00f,0x10:0xf010,"
 188         "0x11:0xf011,0x12:0xf012,0x13:0xf013,0x14:0xf014,"
 189         "0x15:0xf015,0x16:0xf016,0x17:0xf017,0x18:0xf018,"
 190         "0x19:0xf019,0x1a:0xf01a,0x1b:0xf01b,0x1c:0xf01c,"
 191         "0x1d:0xf01d,0x1e:0xf01e,0x1f:0xf01f,"
 192         "0x22:0xf020,0x2a:0xf021,0x3a:0xf022,0x3c:0xf023,"
 193         "0x3e:0xf024,0x3f:0xf025,0x5c:0xf026,0x7c:0xf027,"
 194         "0x0d:0xf00d";
 195
 196 /*****************************************************************************
 197  * Defines, functions and data structures that deal with AppleDouble
 198  *****************************************************************************/
 199
 200 /*
 201  * There are two AppleDouble blobs we deal with:
 202  *
 203  * - ADOUBLE_META - AppleDouble blob used by Netatalk for storing
 204  *   metadata in an xattr
 205  *
 206  * - ADOUBLE_RSRC - AppleDouble blob used by OS X and Netatalk in
 207  *   ._ files
 208  */
 209 typedef enum {ADOUBLE_META, ADOUBLE_RSRC} adouble_type_t;
 210
 211 /* Version info */
 212 #define AD_VERSION2     0x00020000
 213 #define AD_VERSION      AD_VERSION2
 214
 215 /*
 216  * AppleDouble entry IDs.
 217  */
 218 #define ADEID_DFORK         1
 219 #define ADEID_RFORK         2
 220 #define ADEID_NAME          3
 221 #define ADEID_COMMENT       4
 222 #define ADEID_ICONBW        5
 223 #define ADEID_ICONCOL       6
 224 #define ADEID_FILEI         7
 225 #define ADEID_FILEDATESI    8
 226 #define ADEID_FINDERI       9
 227 #define ADEID_MACFILEI      10
 228 #define ADEID_PRODOSFILEI   11
 229 #define ADEID_MSDOSFILEI    12
 230 #define ADEID_SHORTNAME     13
 231 #define ADEID_AFPFILEI      14
 232 #define ADEID_DID           15
 233
 234 /* Private Netatalk entries */
 235 #define ADEID_PRIVDEV       16
 236 #define ADEID_PRIVINO       17
 237 #define ADEID_PRIVSYN       18
 238 #define ADEID_PRIVID        19
 239 #define ADEID_MAX           (ADEID_PRIVID + 1)
 240
 241 /*
 242  * These are the real ids for the private entries,
 243  * as stored in the adouble file
 244  */
 245 #define AD_DEV              0x80444556
 246 #define AD_INO              0x80494E4F
 247 #define AD_SYN              0x8053594E
 248 #define AD_ID               0x8053567E
 249
 250 /* Number of actually used entries */
 251 #define ADEID_NUM_XATTR      8
 252 #define ADEID_NUM_DOT_UND    2
 253 #define ADEID_NUM_RSRC_XATTR 1
 254
 255 /* AppleDouble magic */
 256 #define AD_APPLESINGLE_MAGIC 0x00051600
 257 #define AD_APPLEDOUBLE_MAGIC 0x00051607
 258 #define AD_MAGIC             AD_APPLEDOUBLE_MAGIC
 259
 260 /* Sizes of relevant entry bits */
 261 #define ADEDLEN_MAGIC       4
 262 #define ADEDLEN_VERSION     4
 263 #define ADEDLEN_FILLER      16
 264 #define AD_FILLER_TAG       "Netatalk        " /* should be 16 bytes */
 265 #define ADEDLEN_NENTRIES    2
 266 #define AD_HEADER_LEN       (ADEDLEN_MAGIC + ADEDLEN_VERSION + \
 267                              ADEDLEN_FILLER + ADEDLEN_NENTRIES) /* 26 */
 268 #define AD_ENTRY_LEN_EID    4
 269 #define AD_ENTRY_LEN_OFF    4
 270 #define AD_ENTRY_LEN_LEN    4
 271 #define AD_ENTRY_LEN (AD_ENTRY_LEN_EID + AD_ENTRY_LEN_OFF + AD_ENTRY_LEN_LEN)
 272
 273 /* Field widths */
 274 #define ADEDLEN_NAME            255
 275 #define ADEDLEN_COMMENT         200
 276 #define ADEDLEN_FILEI           16
 277 #define ADEDLEN_FINDERI         32
 278 #define ADEDLEN_FILEDATESI      16
 279 #define ADEDLEN_SHORTNAME       12 /* length up to 8.3 */
 280 #define ADEDLEN_AFPFILEI        4
 281 #define ADEDLEN_MACFILEI        4
 282 #define ADEDLEN_PRODOSFILEI     8
 283 #define ADEDLEN_MSDOSFILEI      2
 284 #define ADEDLEN_DID             4
 285 #define ADEDLEN_PRIVDEV         8
 286 #define ADEDLEN_PRIVINO         8
 287 #define ADEDLEN_PRIVSYN         8
 288 #define ADEDLEN_PRIVID          4
 289
 290 /* Offsets */
 291 #define ADEDOFF_MAGIC         0
 292 #define ADEDOFF_VERSION       (ADEDOFF_MAGIC + ADEDLEN_MAGIC)
 293 #define ADEDOFF_FILLER        (ADEDOFF_VERSION + ADEDLEN_VERSION)
 294 #define ADEDOFF_NENTRIES      (ADEDOFF_FILLER + ADEDLEN_FILLER)
 295
 296 #define ADEDOFF_FINDERI_XATTR    (AD_HEADER_LEN + \
 297                                   (ADEID_NUM_XATTR * AD_ENTRY_LEN))
 298 #define ADEDOFF_COMMENT_XATTR    (ADEDOFF_FINDERI_XATTR    + ADEDLEN_FINDERI)
 299 #define ADEDOFF_FILEDATESI_XATTR (ADEDOFF_COMMENT_XATTR    + ADEDLEN_COMMENT)
 300 #define ADEDOFF_AFPFILEI_XATTR   (ADEDOFF_FILEDATESI_XATTR + \
 301                                   ADEDLEN_FILEDATESI)
 302 #define ADEDOFF_PRIVDEV_XATTR    (ADEDOFF_AFPFILEI_XATTR   + ADEDLEN_AFPFILEI)
 303 #define ADEDOFF_PRIVINO_XATTR    (ADEDOFF_PRIVDEV_XATTR    + ADEDLEN_PRIVDEV)
 304 #define ADEDOFF_PRIVSYN_XATTR    (ADEDOFF_PRIVINO_XATTR    + ADEDLEN_PRIVINO)
 305 #define ADEDOFF_PRIVID_XATTR     (ADEDOFF_PRIVSYN_XATTR    + ADEDLEN_PRIVSYN)
 306
 307 #define ADEDOFF_FINDERI_DOT_UND  (AD_HEADER_LEN + \
 308                                   (ADEID_NUM_DOT_UND * AD_ENTRY_LEN))
 309 #define ADEDOFF_RFORK_DOT_UND    (ADEDOFF_FINDERI_DOT_UND + ADEDLEN_FINDERI)
 310
 311 #define AD_DATASZ_XATTR (AD_HEADER_LEN + \
 312                          (ADEID_NUM_XATTR * AD_ENTRY_LEN) + \
 313                          ADEDLEN_FINDERI + ADEDLEN_COMMENT + \
 314                          ADEDLEN_FILEDATESI + ADEDLEN_AFPFILEI + \
 315                          ADEDLEN_PRIVDEV + ADEDLEN_PRIVINO + \
 316                          ADEDLEN_PRIVSYN + ADEDLEN_PRIVID)
 317
 318 #if AD_DATASZ_XATTR != 402
 319 #error bad size for AD_DATASZ_XATTR
 320 #endif
 321
 322 #define AD_DATASZ_DOT_UND (AD_HEADER_LEN + \
 323                            (ADEID_NUM_DOT_UND * AD_ENTRY_LEN) + \
 324                            ADEDLEN_FINDERI)
 325 #if AD_DATASZ_DOT_UND != 82
 326 #error bad size for AD_DATASZ_DOT_UND
 327 #endif
 328
 329 /*
 330  * Sharemode locks fcntl() offsets
 331  */
 332 #if _FILE_OFFSET_BITS == 64 || defined(HAVE_LARGEFILE)
 333 #define AD_FILELOCK_BASE (UINT64_C(0x7FFFFFFFFFFFFFFF) - 9)
 334 #else
 335 #define AD_FILELOCK_BASE (UINT32_C(0x7FFFFFFF) - 9)
 336 #endif
 337 #define BYTELOCK_MAX (AD_FILELOCK_BASE - 1)
 338
 339 #define AD_FILELOCK_OPEN_WR        (AD_FILELOCK_BASE + 0)
 340 #define AD_FILELOCK_OPEN_RD        (AD_FILELOCK_BASE + 1)
 341 #define AD_FILELOCK_RSRC_OPEN_WR   (AD_FILELOCK_BASE + 2)
 342 #define AD_FILELOCK_RSRC_OPEN_RD   (AD_FILELOCK_BASE + 3)
 343 #define AD_FILELOCK_DENY_WR        (AD_FILELOCK_BASE + 4)
 344 #define AD_FILELOCK_DENY_RD        (AD_FILELOCK_BASE + 5)
 345 #define AD_FILELOCK_RSRC_DENY_WR   (AD_FILELOCK_BASE + 6)
 346 #define AD_FILELOCK_RSRC_DENY_RD   (AD_FILELOCK_BASE + 7)
 347 #define AD_FILELOCK_OPEN_NONE      (AD_FILELOCK_BASE + 8)
 348 #define AD_FILELOCK_RSRC_OPEN_NONE (AD_FILELOCK_BASE + 9)
 349
 350 /* Time stuff we overload the bits a little */
 351 #define AD_DATE_CREATE         0
 352 #define AD_DATE_MODIFY         4
 353 #define AD_DATE_BACKUP         8
 354 #define AD_DATE_ACCESS        12
 355 #define AD_DATE_MASK          (AD_DATE_CREATE | AD_DATE_MODIFY | \
 356                                AD_DATE_BACKUP | AD_DATE_ACCESS)
 357 #define AD_DATE_UNIX          (1 << 10)
 358 #define AD_DATE_START         0x80000000
 359 #define AD_DATE_DELTA         946684800
 360 #define AD_DATE_FROM_UNIX(x)  (htonl((x) - AD_DATE_DELTA))
 361 #define AD_DATE_TO_UNIX(x)    (ntohl(x) + AD_DATE_DELTA)
 362
 363 #define AD_XATTR_HDR_MAGIC    0x41545452 /* 'ATTR' */
 364 #define AD_XATTR_MAX_ENTRIES  1024 /* Some arbitrarily enforced limit */
 365 #define AD_XATTR_HDR_SIZE     36
 366 #define AD_XATTR_MAX_HDR_SIZE 65536
 367
 368 /* Accessor macros */
 369 #define ad_getentrylen(ad,eid)     ((ad)->ad_eid[(eid)].ade_len)
 370 #define ad_getentryoff(ad,eid)     ((ad)->ad_eid[(eid)].ade_off)
 371 #define ad_setentrylen(ad,eid,len) ((ad)->ad_eid[(eid)].ade_len = (len))
 372 #define ad_setentryoff(ad,eid,off) ((ad)->ad_eid[(eid)].ade_off = (off))
 373
 374 /*
 375  * Both struct ad_xattr_header and struct ad_xattr_entry describe the in memory
 376  * representation as well as the on-disk format.
 377  *
 378  * The ad_xattr_header follows the FinderInfo data in the FinderInfo entry if
 379  * the length of the FinderInfo entry is larger then 32 bytes. It is then
 380  * preceeded with 2 bytes padding.
 381  *
 382  * Cf: https://opensource.apple.com/source/xnu/xnu-4570.1.46/bsd/vfs/vfs_xattr.c
 383  */
 384
 385 struct ad_xattr_header {
 386         uint32_t adx_magic;        /* ATTR_HDR_MAGIC */
 387         uint32_t adx_debug_tag;    /* for debugging == file id of owning file */
 388         uint32_t adx_total_size;   /* file offset of end of attribute header + entries + data */
 389         uint32_t adx_data_start;   /* file offset to attribute data area */
 390         uint32_t adx_data_length;  /* length of attribute data area */
 391         uint32_t adx_reserved[3];
 392         uint16_t adx_flags;
 393         uint16_t adx_num_attrs;
 394 };
 395
 396 /* On-disk entries are aligned on 4 byte boundaries */
 397 struct ad_xattr_entry {
 398         uint32_t adx_offset;    /* file offset to data */
 399         uint32_t adx_length;    /* size of attribute data */
 400         uint16_t adx_flags;
 401         uint8_t  adx_namelen;   /* included the NULL terminator */
 402         char    *adx_name;      /* NULL-terminated UTF-8 name */
 403 };
 404
 405 struct ad_entry {
 406         size_t ade_off;
 407         size_t ade_len;
 408 };
 409
 410 struct adouble {
 411         vfs_handle_struct        *ad_handle;
 412         int                       ad_fd;
 413         bool                      ad_opened;
 414         adouble_type_t            ad_type;
 415         uint32_t                  ad_magic;
 416         uint32_t                  ad_version;
 417         struct ad_entry           ad_eid[ADEID_MAX];
 418         char                     *ad_data;
 419         struct ad_xattr_header    adx_header;
 420         struct ad_xattr_entry    *adx_entries;
 421 };
 422
 423 struct ad_entry_order {
 424         uint32_t id, offset, len;
 425 };
 426
 427 /* Netatalk AppleDouble metadata xattr */
 428 static const
 429 struct ad_entry_order entry_order_meta_xattr[ADEID_NUM_XATTR + 1] = {
 430         {ADEID_FINDERI,    ADEDOFF_FINDERI_XATTR,    ADEDLEN_FINDERI},
 431         {ADEID_COMMENT,    ADEDOFF_COMMENT_XATTR,    0},
 432         {ADEID_FILEDATESI, ADEDOFF_FILEDATESI_XATTR, ADEDLEN_FILEDATESI},
 433         {ADEID_AFPFILEI,   ADEDOFF_AFPFILEI_XATTR,   ADEDLEN_AFPFILEI},
 434         {ADEID_PRIVDEV,    ADEDOFF_PRIVDEV_XATTR,    0},
 435         {ADEID_PRIVINO,    ADEDOFF_PRIVINO_XATTR,    0},
 436         {ADEID_PRIVSYN,    ADEDOFF_PRIVSYN_XATTR,    0},
 437         {ADEID_PRIVID,     ADEDOFF_PRIVID_XATTR,     0},
 438         {0, 0, 0}
 439 };
 440
 441 /* AppleDouble resource fork file (the ones prefixed by "._") */
 442 static const
 443 struct ad_entry_order entry_order_dot_und[ADEID_NUM_DOT_UND + 1] = {
 444         {ADEID_FINDERI,    ADEDOFF_FINDERI_DOT_UND,  ADEDLEN_FINDERI},
 445         {ADEID_RFORK,      ADEDOFF_RFORK_DOT_UND,    0},
 446         {0, 0, 0}
 447 };
 448
 449 /*
 450  * Fake AppleDouble entry oder for resource fork xattr.  The xattr
 451  * isn't an AppleDouble file, it simply contains the resource data,
 452  * but in order to be able to use some API calls like ad_getentryoff()
 453  * we build a fake/helper struct adouble with this entry order struct.
 454  */
 455 static const
 456 struct ad_entry_order entry_order_rsrc_xattr[ADEID_NUM_RSRC_XATTR + 1] = {
 457         {ADEID_RFORK, 0, 0},
 458         {0, 0, 0}
 459 };
 460
 461 /* Conversion from enumerated id to on-disk AppleDouble id */
 462 #define AD_EID_DISK(a) (set_eid[a])
 463 static const uint32_t set_eid[] = {
 464         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
 465         AD_DEV, AD_INO, AD_SYN, AD_ID
 466 };
 467
 468 struct fio {
 469         /* tcon config handle */
 470         struct fruit_config_data *config;
 471
 472         /* Denote stream type, meta or rsrc */
 473         adouble_type_t type;
 474 };
 475
 476 /*
 477  * Forward declarations
 478  */
 479 static struct adouble *ad_init(TALLOC_CTX *ctx, vfs_handle_struct *handle,
 480                                adouble_type_t type);
 481 static int ad_set(struct adouble *ad, const struct smb_filename *smb_fname);
 482 static int ad_fset(struct adouble *ad, files_struct *fsp);
 483 static int adouble_path(TALLOC_CTX *ctx,
 484                         const struct smb_filename *smb_fname__in,
 485                         struct smb_filename **ppsmb_fname_out);
 486 static AfpInfo *afpinfo_new(TALLOC_CTX *ctx);
 487 static ssize_t afpinfo_pack(const AfpInfo *ai, char *buf);
 488 static AfpInfo *afpinfo_unpack(TALLOC_CTX *ctx, const void *data);
 489
 490
 491 /**
 492  * Return a pointer to an AppleDouble entry
 493  *
 494  * Returns NULL if the entry is not present
 495  **/
 496 static char *ad_get_entry(const struct adouble *ad, int eid)
 497 {
 498         off_t off = ad_getentryoff(ad, eid);
 499         size_t len = ad_getentrylen(ad, eid);
 500
 501         if (off == 0 || len == 0) {
 502                 return NULL;
 503         }
 504
 505         return ad->ad_data + off;
 506 }
 507
 508 /**
 509  * Get a date
 510  **/
 511 static int ad_getdate(const struct adouble *ad,
 512                       unsigned int dateoff,
 513                       uint32_t *date)
 514 {
 515         bool xlate = (dateoff & AD_DATE_UNIX);
 516         char *p = NULL;
 517
 518         dateoff &= AD_DATE_MASK;
 519         p = ad_get_entry(ad, ADEID_FILEDATESI);
 520         if (p == NULL) {
 521                 return -1;
 522         }
 523
 524         if (dateoff > AD_DATE_ACCESS) {
 525             return -1;
 526         }
 527
 528         memcpy(date, p + dateoff, sizeof(uint32_t));
 529
 530         if (xlate) {
 531                 *date = AD_DATE_TO_UNIX(*date);
 532         }
 533         return 0;
 534 }
 535
 536 /**
 537  * Set a date
 538  **/
 539 static int ad_setdate(struct adouble *ad, unsigned int dateoff, uint32_t date)
 540 {
 541         bool xlate = (dateoff & AD_DATE_UNIX);
 542         char *p = NULL;
 543
 544         p = ad_get_entry(ad, ADEID_FILEDATESI);
 545         if (p == NULL) {
 546                 return -1;
 547         }
 548
 549         dateoff &= AD_DATE_MASK;
 550         if (xlate) {
 551                 date = AD_DATE_FROM_UNIX(date);
 552         }
 553
 554         if (dateoff > AD_DATE_ACCESS) {
 555                 return -1;
 556         }
 557
 558         memcpy(p + dateoff, &date, sizeof(date));
 559
 560         return 0;
 561 }
 562
 563
 564 /**
 565  * Map on-disk AppleDouble id to enumerated id
 566  **/
 567 static uint32_t get_eid(uint32_t eid)
 568 {
 569         if (eid <= 15) {
 570                 return eid;
 571         }
 572
 573         switch (eid) {
 574         case AD_DEV:
 575                 return ADEID_PRIVDEV;
 576         case AD_INO:
 577                 return ADEID_PRIVINO;
 578         case AD_SYN:
 579                 return ADEID_PRIVSYN;
 580         case AD_ID:
 581                 return ADEID_PRIVID;
 582         default:
 583                 break;
 584         }
 585
 586         return 0;
 587 }
 588
 589 /**
 590  * Pack AppleDouble structure into data buffer
 591  **/
 592 static bool ad_pack(struct adouble *ad)
 593 {
 594         uint32_t       eid;
 595         uint16_t       nent;
 596         uint32_t       bufsize;
 597         uint32_t       offset = 0;
 598
 599         bufsize = talloc_get_size(ad->ad_data);
 600         if (bufsize < AD_DATASZ_DOT_UND) {
 601                 DBG_ERR("bad buffer size [0x%" PRIx32 "]\n", bufsize);
 602                 return false;
 603         }
 604
 605         if (offset + ADEDLEN_MAGIC < offset ||
 606                         offset + ADEDLEN_MAGIC >= bufsize) {
 607                 return false;
 608         }
 609         RSIVAL(ad->ad_data, offset, ad->ad_magic);
 610         offset += ADEDLEN_MAGIC;
 611
 612         if (offset + ADEDLEN_VERSION < offset ||
 613                         offset + ADEDLEN_VERSION >= bufsize) {
 614                 return false;
 615         }
 616         RSIVAL(ad->ad_data, offset, ad->ad_version);
 617         offset += ADEDLEN_VERSION;
 618
 619         if (offset + ADEDLEN_FILLER < offset ||
 620                         offset + ADEDLEN_FILLER >= bufsize) {
 621                 return false;
 622         }
 623         if (ad->ad_type == ADOUBLE_RSRC) {
 624                 memcpy(ad->ad_data + offset, AD_FILLER_TAG, ADEDLEN_FILLER);
 625         }
 626         offset += ADEDLEN_FILLER;
 627
 628         if (offset + ADEDLEN_NENTRIES < offset ||
 629                         offset + ADEDLEN_NENTRIES >= bufsize) {
 630                 return false;
 631         }
 632         offset += ADEDLEN_NENTRIES;
 633
 634         for (eid = 0, nent = 0; eid < ADEID_MAX; eid++) {
 635                 if (ad->ad_eid[eid].ade_off == 0) {
 636                         /*
 637                          * ade_off is also used as indicator whether a
 638                          * specific entry is used or not
 639                          */
 640                         continue;
 641                 }
 642
 643                 if (offset + AD_ENTRY_LEN_EID < offset ||
 644                                 offset + AD_ENTRY_LEN_EID >= bufsize) {
 645                         return false;
 646                 }
 647                 RSIVAL(ad->ad_data, offset, AD_EID_DISK(eid));
 648                 offset += AD_ENTRY_LEN_EID;
 649
 650                 if (offset + AD_ENTRY_LEN_OFF < offset ||
 651                                 offset + AD_ENTRY_LEN_OFF >= bufsize) {
 652                         return false;
 653                 }
 654                 RSIVAL(ad->ad_data, offset, ad->ad_eid[eid].ade_off);
 655                 offset += AD_ENTRY_LEN_OFF;
 656
 657                 if (offset + AD_ENTRY_LEN_LEN < offset ||
 658                                 offset + AD_ENTRY_LEN_LEN >= bufsize) {
 659                         return false;
 660                 }
 661                 RSIVAL(ad->ad_data, offset, ad->ad_eid[eid].ade_len);
 662                 offset += AD_ENTRY_LEN_LEN;
 663
 664                 nent++;
 665         }
 666
 667         if (ADEDOFF_NENTRIES + 2 >= bufsize) {
 668                 return false;
 669         }
 670         RSSVAL(ad->ad_data, ADEDOFF_NENTRIES, nent);
 671
 672         return true;
 673 }
 674
 675 static bool ad_unpack_xattrs(struct adouble *ad)
 676 {
 677         struct ad_xattr_header *h = &ad->adx_header;
 678         const char *p = ad->ad_data;
 679         uint32_t hoff;
 680         uint32_t i;
 681
 682         if (ad_getentrylen(ad, ADEID_FINDERI) <= ADEDLEN_FINDERI) {
 683                 return true;
 684         }
 685
 686         /* 2 bytes padding */
 687         hoff = ad_getentryoff(ad, ADEID_FINDERI) + ADEDLEN_FINDERI + 2;
 688
 689         h->adx_magic       = RIVAL(p, hoff + 0);
 690         h->adx_debug_tag   = RIVAL(p, hoff + 4); /* Not used -> not checked */
 691         h->adx_total_size  = RIVAL(p, hoff + 8);
 692         h->adx_data_start  = RIVAL(p, hoff + 12);
 693         h->adx_data_length = RIVAL(p, hoff + 16);
 694         h->adx_flags       = RSVAL(p, hoff + 32); /* Not used -> not checked */
 695         h->adx_num_attrs   = RSVAL(p, hoff + 34);
 696
 697         if (h->adx_magic != AD_XATTR_HDR_MAGIC) {
 698                 DBG_ERR("Bad magic: 0x%" PRIx32 "\n", h->adx_magic);
 699                 return false;
 700         }
 701
 702         if (h->adx_total_size > ad_getentryoff(ad, ADEID_RFORK)) {
 703                 DBG_ERR("Bad total size: 0x%" PRIx32 "\n", h->adx_total_size);
 704                 return false;
 705         }
 706         if (h->adx_total_size > AD_XATTR_MAX_HDR_SIZE) {
 707                 DBG_ERR("Bad total size: 0x%" PRIx32 "\n", h->adx_total_size);
 708                 return false;
 709         }
 710
 711         if (h->adx_data_start < (hoff + AD_XATTR_HDR_SIZE)) {
 712                 DBG_ERR("Bad start: 0x%" PRIx32 "\n", h->adx_data_start);
 713                 return false;
 714         }
 715
 716         if ((h->adx_data_start + h->adx_data_length) < h->adx_data_start) {
 717                 DBG_ERR("Bad length: %" PRIu32 "\n", h->adx_data_length);
 718                 return false;
 719         }
 720         if ((h->adx_data_start + h->adx_data_length) >
 721             ad->adx_header.adx_total_size)
 722         {
 723                 DBG_ERR("Bad length: %" PRIu32 "\n", h->adx_data_length);
 724                 return false;
 725         }
 726
 727         if (h->adx_num_attrs > AD_XATTR_MAX_ENTRIES) {
 728                 DBG_ERR("Bad num xattrs: %" PRIu16 "\n", h->adx_num_attrs);
 729                 return false;
 730         }
 731
 732         if (h->adx_num_attrs == 0) {
 733                 return true;
 734         }
 735
 736         ad->adx_entries = talloc_zero_array(
 737                 ad, struct ad_xattr_entry, h->adx_num_attrs);
 738         if (ad->adx_entries == NULL) {
 739                 return false;
 740         }
 741
 742         hoff += AD_XATTR_HDR_SIZE;
 743
 744         for (i = 0; i < h->adx_num_attrs; i++) {
 745                 struct ad_xattr_entry *e = &ad->adx_entries[i];
 746
 747                 hoff = (hoff + 3) & ~3;
 748
 749                 e->adx_offset  = RIVAL(p, hoff + 0);
 750                 e->adx_length  = RIVAL(p, hoff + 4);
 751                 e->adx_flags   = RSVAL(p, hoff + 8);
 752                 e->adx_namelen = *(p + hoff + 10);
 753
 754                 if (e->adx_offset >= ad->adx_header.adx_total_size) {
 755                         DBG_ERR("Bad adx_offset: %" PRIx32 "\n",
 756                                 e->adx_offset);
 757                         return false;
 758                 }
 759
 760                 if ((e->adx_offset + e->adx_length) < e->adx_offset) {
 761                         DBG_ERR("Bad adx_length: %" PRIx32 "\n",
 762                                 e->adx_length);
 763                         return false;
 764                 }
 765
 766                 if ((e->adx_offset + e->adx_length) >
 767                     ad->adx_header.adx_total_size)
 768                 {
 769                         DBG_ERR("Bad adx_length: %" PRIx32 "\n",
 770                                 e->adx_length);
 771                         return false;
 772                 }
 773
 774                 if (e->adx_namelen == 0) {
 775                         DBG_ERR("Bad adx_namelen: %" PRIx32 "\n",
 776                                 e->adx_namelen);
 777                         return false;
 778                 }
 779                 if ((hoff + 11 + e->adx_namelen) < hoff + 11) {
 780                         DBG_ERR("Bad adx_namelen: %" PRIx32 "\n",
 781                                 e->adx_namelen);
 782                         return false;
 783                 }
 784                 if ((hoff + 11 + e->adx_namelen) >
 785                     ad->adx_header.adx_data_start)
 786                 {
 787                         DBG_ERR("Bad adx_namelen: %" PRIx32 "\n",
 788                                 e->adx_namelen);
 789                         return false;
 790                 }
 791
 792                 e->adx_name = talloc_strndup(ad->adx_entries,
 793                                              p + hoff + 11,
 794                                              e->adx_namelen);
 795                 if (e->adx_name == NULL) {
 796                         return false;
 797                 }
 798
 799                 DBG_DEBUG("xattr [%s] offset [0x%x] size [0x%x]\n",
 800                           e->adx_name, e->adx_offset, e->adx_length);
 801                 dump_data(10, (uint8_t *)(ad->ad_data + e->adx_offset),
 802                           e->adx_length);
 803
 804                 hoff += 11 + e->adx_namelen;
 805         }
 806
 807         return true;
 808 }
 809
 810 /**
 811  * Unpack an AppleDouble blob into a struct adoble
 812  **/
 813 static bool ad_unpack(struct adouble *ad, const size_t nentries,
 814                       size_t filesize)
 815 {
 816         size_t bufsize = talloc_get_size(ad->ad_data);
 817         size_t adentries, i;
 818         uint32_t eid, len, off;
 819         bool ok;
 820
 821         /*
 822          * The size of the buffer ad->ad_data is checked when read, so
 823          * we wouldn't have to check our own offsets, a few extra
 824          * checks won't hurt though. We have to check the offsets we
 825          * read from the buffer anyway.
 826          */
 827
 828         if (bufsize < (AD_HEADER_LEN + (AD_ENTRY_LEN * nentries))) {
 829                 DEBUG(1, ("bad size\n"));
 830                 return false;
 831         }
 832
 833         ad->ad_magic = RIVAL(ad->ad_data, 0);
 834         ad->ad_version = RIVAL(ad->ad_data, ADEDOFF_VERSION);
 835         if ((ad->ad_magic != AD_MAGIC) || (ad->ad_version != AD_VERSION)) {
 836                 DEBUG(1, ("wrong magic or version\n"));
 837                 return false;
 838         }
 839
 840         adentries = RSVAL(ad->ad_data, ADEDOFF_NENTRIES);
 841         if (adentries != nentries) {
 842                 DEBUG(1, ("invalid number of entries: %zu\n",
 843                           adentries));
 844                 return false;
 845         }
 846
 847         /* now, read in the entry bits */
 848         for (i = 0; i < adentries; i++) {
 849                 eid = RIVAL(ad->ad_data, AD_HEADER_LEN + (i * AD_ENTRY_LEN));
 850                 eid = get_eid(eid);
 851                 off = RIVAL(ad->ad_data, AD_HEADER_LEN + (i * AD_ENTRY_LEN) + 4);
 852                 len = RIVAL(ad->ad_data, AD_HEADER_LEN + (i * AD_ENTRY_LEN) + 8);
 853
 854                 if (!eid || eid >= ADEID_MAX) {
 855                         DEBUG(1, ("bogus eid %d\n", eid));
 856                         return false;
 857                 }
 858
 859                 /*
 860                  * All entries other than the resource fork are
 861                  * expected to be read into the ad_data buffer, so
 862                  * ensure the specified offset is within that bound
 863                  */
 864                 if ((off > bufsize) && (eid != ADEID_RFORK)) {
 865                         DEBUG(1, ("bogus eid %d: off: %" PRIu32 ", len: %" PRIu32 "\n",
 866                                   eid, off, len));
 867                         return false;
 868                 }
 869
 870                 /*
 871                  * All entries besides FinderInfo and resource fork
 872                  * must fit into the buffer. FinderInfo is special as
 873                  * it may be larger then the default 32 bytes (if it
 874                  * contains marshalled xattrs), but we will fixup that
 875                  * in ad_convert(). And the resource fork is never
 876                  * accessed directly by the ad_data buf (also see
 877                  * comment above) anyway.
 878                  */
 879                 if ((eid != ADEID_RFORK) &&
 880                     (eid != ADEID_FINDERI) &&
 881                     ((off + len) > bufsize)) {
 882                         DEBUG(1, ("bogus eid %d: off: %" PRIu32 ", len: %" PRIu32 "\n",
 883                                   eid, off, len));
 884                         return false;
 885                 }
 886
 887                 /*
 888                  * That would be obviously broken
 889                  */
 890                 if (off > filesize) {
 891                         DEBUG(1, ("bogus eid %d: off: %" PRIu32 ", len: %" PRIu32 "\n",
 892                                   eid, off, len));
 893                         return false;
 894                 }
 895
 896                 /*
 897                  * Check for any entry that has its end beyond the
 898                  * filesize.
 899                  */
 900                 if (off + len < off) {
 901                         DEBUG(1, ("offset wrap in eid %d: off: %" PRIu32
 902                                   ", len: %" PRIu32 "\n",
 903                                   eid, off, len));
 904                         return false;
 905
 906                 }
 907                 if (off + len > filesize) {
 908                         /*
 909                          * If this is the resource fork entry, we fix
 910                          * up the length, for any other entry we bail
 911                          * out.
 912                          */
 913                         if (eid != ADEID_RFORK) {
 914                                 DEBUG(1, ("bogus eid %d: off: %" PRIu32
 915                                           ", len: %" PRIu32 "\n",
 916                                           eid, off, len));
 917                                 return false;
 918                         }
 919
 920                         /*
 921                          * Fixup the resource fork entry by limiting
 922                          * the size to entryoffset - filesize.
 923                          */
 924                         len = filesize - off;
 925                         DEBUG(1, ("Limiting ADEID_RFORK: off: %" PRIu32
 926                                   ", len: %" PRIu32 "\n", off, len));
 927                 }
 928
 929                 ad->ad_eid[eid].ade_off = off;
 930                 ad->ad_eid[eid].ade_len = len;
 931         }
 932
 933         ok = ad_unpack_xattrs(ad);
 934         if (!ok) {
 935                 return false;
 936         }
 937
 938         return true;
 939 }
 940
 941 static bool ad_convert_xattr(struct adouble *ad,
 942                              const struct smb_filename *smb_fname,
 943                              char *map)
 944 {
 945         static struct char_mappings **string_replace_cmaps = NULL;
 946         uint16_t i;
 947         int saved_errno = 0;
 948         NTSTATUS status;
 949
 950         if (ad->adx_header.adx_num_attrs == 0) {
 951                 return true;
 952         }
 953
 954         if (string_replace_cmaps == NULL) {
 955                 const char **mappings = NULL;
 956
 957                 mappings = str_list_make_v3_const(
 958                         talloc_tos(), fruit_catia_maps, NULL);
 959                 if (mappings == NULL) {
 960                         return false;
 961                 }
 962                 string_replace_cmaps = string_replace_init_map(mappings);
 963                 TALLOC_FREE(mappings);
 964         }
 965
 966         for (i = 0; i < ad->adx_header.adx_num_attrs; i++) {
 967                 struct ad_xattr_entry *e = &ad->adx_entries[i];
 968                 char *mapped_name = NULL;
 969                 char *tmp = NULL;
 970                 struct smb_filename *stream_name = NULL;
 971                 files_struct *fsp = NULL;
 972                 ssize_t nwritten;
 973
 974                 status = string_replace_allocate(ad->ad_handle->conn,
 975                                                  e->adx_name,
 976                                                  string_replace_cmaps,
 977                                                  talloc_tos(),
 978                                                  &mapped_name,
 979                                                  vfs_translate_to_windows);
 980                 if (!NT_STATUS_IS_OK(status) &&
 981                     !NT_STATUS_EQUAL(status, NT_STATUS_NONE_MAPPED))
 982                 {
 983                         DBG_ERR("string_replace_allocate failed\n");
 984                         return -1;
 985                 }
 986
 987                 tmp = mapped_name;
 988                 mapped_name = talloc_asprintf(talloc_tos(), ":%s", tmp);
 989                 TALLOC_FREE(tmp);
 990                 if (mapped_name == NULL) {
 991                         return -1;
 992                 }
 993
 994                 stream_name = synthetic_smb_fname(talloc_tos(),
 995                                                   smb_fname->base_name,
 996                                                   mapped_name,
 997                                                   NULL,
 998                                                   smb_fname->flags);
 999                 TALLOC_FREE(mapped_name);
1000                 if (stream_name == NULL) {
1001                         DBG_ERR("synthetic_smb_fname failed\n");
1002                         return -1;
1003                 }
1004
1005                 DBG_DEBUG("stream_name: %s\n", smb_fname_str_dbg(stream_name));
1006
1007                 status = SMB_VFS_CREATE_FILE(
1008                         ad->ad_handle->conn,            /* conn */
1009                         NULL,                           /* req */
1010                         0,                              /* root_dir_fid */
1011                         stream_name,                    /* fname */
1012                         FILE_GENERIC_WRITE,             /* access_mask */
1013                         FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
1014                         FILE_OPEN_IF,                   /* create_disposition */
1015                         0,                              /* create_options */
1016                         0,                              /* file_attributes */
1017                         INTERNAL_OPEN_ONLY,             /* oplock_request */
1018                         NULL,                           /* lease */
1019                         0,                              /* allocation_size */
1020                         0,                              /* private_flags */
1021                         NULL,                           /* sd */
1022                         NULL,                           /* ea_list */
1023                         &fsp,                           /* result */
1024                         NULL,                           /* psbuf */
1025                         NULL, NULL);                    /* create context */
1026                 TALLOC_FREE(stream_name);
1027                 if (!NT_STATUS_IS_OK(status)) {
1028                         DBG_ERR("SMB_VFS_CREATE_FILE failed\n");
1029                         return -1;
1030                 }
1031
1032                 nwritten = SMB_VFS_PWRITE(fsp,
1033                                           map + e->adx_offset,
1034                                           e->adx_length,
1035                                           0);
1036                 if (nwritten == -1) {
1037                         DBG_ERR("SMB_VFS_PWRITE failed\n");
1038                         saved_errno = errno;
1039                         close_file(NULL, fsp, ERROR_CLOSE);
1040                         errno = saved_errno;
1041                         return -1;
1042                 }
1043
1044                 status = close_file(NULL, fsp, NORMAL_CLOSE);
1045                 if (!NT_STATUS_IS_OK(status)) {
1046                         return -1;
1047                 }
1048                 fsp = NULL;
1049         }
1050
1051         return true;
1052 }
1053
1054 /**
1055  * Convert from Apple's ._ file to Netatalk
1056  *
1057  * Apple's AppleDouble may contain a FinderInfo entry longer then 32
1058  * bytes containing packed xattrs. Netatalk can't deal with that, so
1059  * we simply discard the packed xattrs.
1060  *
1061  * @return -1 in case an error occurred, 0 if no conversion was done, 1
1062  * otherwise
1063  **/
1064 static int ad_convert(struct adouble *ad,
1065                       const struct smb_filename *smb_fname,
1066                       int fd)
1067 {
1068         int rc = 0;
1069         char *map = MAP_FAILED;
1070         size_t origlen;
1071         bool ok;
1072
1073         origlen = ad_getentryoff(ad, ADEID_RFORK) +
1074                 ad_getentrylen(ad, ADEID_RFORK);
1075
1076         /* FIXME: direct use of mmap(), vfs_aio_fork does it too */
1077         map = mmap(NULL, origlen, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
1078         if (map == MAP_FAILED) {
1079                 DEBUG(2, ("mmap AppleDouble: %s\n", strerror(errno)));
1080                 rc = -1;
1081                 goto exit;
1082         }
1083
1084         ok = ad_convert_xattr(ad, smb_fname, map);
1085         if (!ok) {
1086                 munmap(map, origlen);
1087                 return -1;
1088         }
1089
1090         if (ad_getentrylen(ad, ADEID_RFORK) > 0) {
1091                 memmove(map + ad_getentryoff(ad, ADEID_FINDERI) + ADEDLEN_FINDERI,
1092                         map + ad_getentryoff(ad, ADEID_RFORK),
1093                         ad_getentrylen(ad, ADEID_RFORK));
1094         }
1095
1096         ad_setentrylen(ad, ADEID_FINDERI, ADEDLEN_FINDERI);
1097         ad_setentryoff(ad, ADEID_RFORK,
1098                        ad_getentryoff(ad, ADEID_FINDERI) + ADEDLEN_FINDERI);
1099
1100         /*
1101          * FIXME: direct ftruncate(), but we don't have a fsp for the
1102          * VFS call
1103          */
1104         rc = ftruncate(fd, ad_getentryoff(ad, ADEID_RFORK)
1105                        + ad_getentrylen(ad, ADEID_RFORK));
1106
1107 exit:
1108         if (map != MAP_FAILED) {
1109                 munmap(map, origlen);
1110         }
1111         return rc;
1112 }
1113
1114 /**
1115  * Read and parse Netatalk AppleDouble metadata xattr
1116  **/
1117 static ssize_t ad_read_meta(struct adouble *ad,
1118                                 const struct smb_filename *smb_fname)
1119 {
1120         int      rc = 0;
1121         ssize_t  ealen;
1122         bool     ok;
1123
1124         DEBUG(10, ("reading meta xattr for %s\n", smb_fname->base_name));
1125
1126         ealen = SMB_VFS_GETXATTR(ad->ad_handle->conn, smb_fname,
1127                                  AFPINFO_EA_NETATALK, ad->ad_data,
1128                                  AD_DATASZ_XATTR);
1129         if (ealen == -1) {
1130                 switch (errno) {
1131                 case ENOATTR:
1132                 case ENOENT:
1133                         if (errno == ENOATTR) {
1134                                 errno = ENOENT;
1135                         }
1136                         rc = -1;
1137                         goto exit;
1138                 default:
1139                         DEBUG(2, ("error reading meta xattr: %s\n",
1140                                   strerror(errno)));
1141                         rc = -1;
1142                         goto exit;
1143                 }
1144         }
1145         if (ealen != AD_DATASZ_XATTR) {
1146                 DEBUG(2, ("bad size %zd\n", ealen));
1147                 errno = EINVAL;
1148                 rc = -1;
1149                 goto exit;
1150         }
1151
1152         /* Now parse entries */
1153         ok = ad_unpack(ad, ADEID_NUM_XATTR, AD_DATASZ_XATTR);
1154         if (!ok) {
1155                 DEBUG(2, ("invalid AppleDouble metadata xattr\n"));
1156                 errno = EINVAL;
1157                 rc = -1;
1158                 goto exit;
1159         }
1160
1161         if (!ad_getentryoff(ad, ADEID_FINDERI)
1162             || !ad_getentryoff(ad, ADEID_COMMENT)
1163             || !ad_getentryoff(ad, ADEID_FILEDATESI)
1164             || !ad_getentryoff(ad, ADEID_AFPFILEI)
1165             || !ad_getentryoff(ad, ADEID_PRIVDEV)
1166             || !ad_getentryoff(ad, ADEID_PRIVINO)
1167             || !ad_getentryoff(ad, ADEID_PRIVSYN)
1168             || !ad_getentryoff(ad, ADEID_PRIVID)) {
1169                 DEBUG(2, ("invalid AppleDouble metadata xattr\n"));
1170                 errno = EINVAL;
1171                 rc = -1;
1172                 goto exit;
1173         }
1174
1175 exit:
1176         DEBUG(10, ("reading meta xattr for %s, rc: %d\n",
1177                 smb_fname->base_name, rc));
1178
1179         if (rc != 0) {
1180                 ealen = -1;
1181                 if (errno == EINVAL) {
1182                         become_root();
1183                         removexattr(smb_fname->base_name, AFPINFO_EA_NETATALK);
1184                         unbecome_root();
1185                         errno = ENOENT;
1186                 }
1187         }
1188         return ealen;
1189 }
1190
1191 static int ad_open_rsrc_xattr(const struct smb_filename *smb_fname,
1192                                 int flags,
1193                                 mode_t mode)
1194 {
1195 #ifdef HAVE_ATTROPEN
1196         /* FIXME: direct Solaris xattr syscall */
1197         return attropen(smb_fname->base_name,
1198                         AFPRESOURCE_EA_NETATALK, flags, mode);
1199 #else
1200         errno = ENOSYS;
1201         return -1;
1202 #endif
1203 }
1204
1205 static int ad_open_rsrc_adouble(const struct smb_filename *smb_fname,
1206                                 int flags,
1207                                 mode_t mode)
1208 {
1209         int ret;
1210         int fd;
1211         struct smb_filename *adp_smb_fname = NULL;
1212
1213         ret = adouble_path(talloc_tos(), smb_fname, &adp_smb_fname);
1214         if (ret != 0) {
1215                 return -1;
1216         }
1217
1218         fd = open(adp_smb_fname->base_name, flags, mode);
1219         TALLOC_FREE(adp_smb_fname);
1220
1221         return fd;
1222 }
1223
1224 static int ad_open_rsrc(vfs_handle_struct *handle,
1225                         const struct smb_filename *smb_fname,
1226                         int flags,
1227                         mode_t mode)
1228 {
1229         struct fruit_config_data *config = NULL;
1230         int fd;
1231
1232         SMB_VFS_HANDLE_GET_DATA(handle, config,
1233                                 struct fruit_config_data, return -1);
1234
1235         if (config->rsrc == FRUIT_RSRC_XATTR) {
1236                 fd = ad_open_rsrc_xattr(smb_fname, flags, mode);
1237         } else {
1238                 fd = ad_open_rsrc_adouble(smb_fname, flags, mode);
1239         }
1240
1241         return fd;
1242 }
1243
1244 /*
1245  * Here's the deal: for ADOUBLE_META we can do without an fd as we can issue
1246  * path based xattr calls. For ADOUBLE_RSRC however we need a full-fledged fd
1247  * for file IO on the ._ file.
1248  */
1249 static int ad_open(vfs_handle_struct *handle,
1250                    struct adouble *ad,
1251                    files_struct *fsp,
1252                    const struct smb_filename *smb_fname,
1253                    int flags,
1254                    mode_t mode)
1255 {
1256         int fd;
1257
1258         DBG_DEBUG("Path [%s] type [%s]\n", smb_fname->base_name,
1259                   ad->ad_type == ADOUBLE_META ? "meta" : "rsrc");
1260
1261         if (ad->ad_type == ADOUBLE_META) {
1262                 return 0;
1263         }
1264
1265         if ((fsp != NULL) && (fsp->fh != NULL) && (fsp->fh->fd != -1)) {
1266                 ad->ad_fd = fsp->fh->fd;
1267                 ad->ad_opened = false;
1268                 return 0;
1269         }
1270
1271         fd = ad_open_rsrc(handle, smb_fname, flags, mode);
1272         if (fd == -1) {
1273                 return -1;
1274         }
1275         ad->ad_opened = true;
1276         ad->ad_fd = fd;
1277
1278         DBG_DEBUG("Path [%s] type [%s] fd [%d]\n",
1279                   smb_fname->base_name,
1280                   ad->ad_type == ADOUBLE_META ? "meta" : "rsrc", fd);
1281
1282         return 0;
1283 }
1284
1285 static ssize_t ad_read_rsrc_xattr(struct adouble *ad)
1286 {
1287         int ret;
1288         SMB_STRUCT_STAT st;
1289
1290         /* FIXME: direct sys_fstat(), don't have an fsp */
1291         ret = sys_fstat(ad->ad_fd, &st,
1292                         lp_fake_directory_create_times(
1293                                 SNUM(ad->ad_handle->conn)));
1294         if (ret != 0) {
1295                 return -1;
1296         }
1297
1298         ad_setentrylen(ad, ADEID_RFORK, st.st_ex_size);
1299         return st.st_ex_size;
1300 }
1301
1302 static ssize_t ad_read_rsrc_adouble(struct adouble *ad,
1303                                 const struct smb_filename *smb_fname)
1304 {
1305         SMB_STRUCT_STAT sbuf;
1306         char *p_ad = NULL;
1307         AfpInfo *ai = NULL;
1308         DATA_BLOB aiblob;
1309         struct smb_filename *stream_name = NULL;
1310         files_struct *fsp = NULL;
1311         ssize_t len;
1312         size_t size;
1313         ssize_t nwritten;
1314         NTSTATUS status;
1315         int saved_errno = 0;
1316         int ret;
1317         bool ok;
1318
1319         ret = sys_fstat(ad->ad_fd, &sbuf, lp_fake_directory_create_times(
1320                                 SNUM(ad->ad_handle->conn)));
1321         if (ret != 0) {
1322                 return -1;
1323         }
1324
1325         /*
1326          * AppleDouble file header content and size, two cases:
1327          *
1328          * - without xattrs it is exactly AD_DATASZ_DOT_UND (82) bytes large
1329          * - with embedded xattrs it can be larger, up to AD_XATTR_MAX_HDR_SIZE
1330          *
1331          * Read as much as we can up to AD_XATTR_MAX_HDR_SIZE.
1332          */
1333         size = sbuf.st_ex_size;
1334         if (size > talloc_array_length(ad->ad_data)) {
1335                 if (size > AD_XATTR_MAX_HDR_SIZE) {
1336                         size = AD_XATTR_MAX_HDR_SIZE;
1337                 }
1338                 p_ad = talloc_realloc(ad, ad->ad_data, char, size);
1339                 if (p_ad == NULL) {
1340                         return -1;
1341                 }
1342                 ad->ad_data = p_ad;
1343         }
1344
1345         len = sys_pread(ad->ad_fd, ad->ad_data,
1346                         talloc_array_length(ad->ad_data), 0);
1347         if (len != talloc_array_length(ad->ad_data)) {
1348                 DBG_NOTICE("%s %s: bad size: %zd\n",
1349                            smb_fname->base_name, strerror(errno), len);
1350                 return -1;
1351         }
1352
1353         /* Now parse entries */
1354         ok = ad_unpack(ad, ADEID_NUM_DOT_UND, sbuf.st_ex_size);
1355         if (!ok) {
1356                 DBG_ERR("invalid AppleDouble resource %s\n",
1357                         smb_fname->base_name);
1358                 errno = EINVAL;
1359                 return -1;
1360         }
1361
1362         if ((ad_getentryoff(ad, ADEID_FINDERI) != ADEDOFF_FINDERI_DOT_UND)
1363             || (ad_getentrylen(ad, ADEID_FINDERI) < ADEDLEN_FINDERI)
1364             || (ad_getentryoff(ad, ADEID_RFORK) < ADEDOFF_RFORK_DOT_UND)) {
1365                 DBG_ERR("invalid AppleDouble resource %s\n",
1366                         smb_fname->base_name);
1367                 errno = EINVAL;
1368                 return -1;
1369         }
1370
1371         if (ad_getentrylen(ad, ADEID_FINDERI) == ADEDLEN_FINDERI) {
1372                 return len;
1373         }
1374
1375         /*
1376          * Try to fixup AppleDouble files created by OS X with xattrs
1377          * appended to the ADEID_FINDERI entry. We simply remove the
1378          * xattrs blob, this means any fancy xattr that was stored
1379          * there is lost.
1380          */
1381
1382         ret = ad_convert(ad, smb_fname, ad->ad_fd);
1383         if (ret != 0) {
1384                 DBG_WARNING("Failed to convert [%s]\n", smb_fname->base_name);
1385                 return len;
1386         }
1387
1388         ok = ad_pack(ad);
1389         if (!ok) {
1390                 DBG_WARNING("ad_pack [%s] failed\n", smb_fname->base_name);
1391                 return -1;
1392         }
1393
1394         len = sys_pwrite(ad->ad_fd, ad->ad_data, AD_DATASZ_DOT_UND, 0);
1395         if (len != AD_DATASZ_DOT_UND) {
1396                 DBG_ERR("%s: bad size: %zd\n", smb_fname->base_name, len);
1397                 return -1;
1398         }
1399
1400         p_ad = ad_get_entry(ad, ADEID_FINDERI);
1401         if (p_ad == NULL) {
1402                 return -1;
1403         }
1404
1405         ai = afpinfo_new(talloc_tos());
1406         if (ai == NULL) {
1407                 return -1;
1408         }
1409
1410         memcpy(ai->afpi_FinderInfo, p_ad, ADEDLEN_FINDERI);
1411
1412         aiblob = data_blob_talloc(talloc_tos(), NULL, AFP_INFO_SIZE);
1413         if (aiblob.data == NULL) {
1414                 TALLOC_FREE(ai);
1415                 return -1;
1416         }
1417
1418         size = afpinfo_pack(ai, (char *)aiblob.data);
1419         TALLOC_FREE(ai);
1420         if (size != AFP_INFO_SIZE) {
1421                 return -1;
1422         }
1423
1424         stream_name = synthetic_smb_fname(talloc_tos(),
1425                                           smb_fname->base_name,
1426                                           AFPINFO_STREAM,
1427                                           NULL,
1428                                           smb_fname->flags);
1429         if (stream_name == NULL) {
1430                 data_blob_free(&aiblob);
1431                 DBG_ERR("synthetic_smb_fname failed\n");
1432                 return -1;
1433         }
1434
1435         DBG_DEBUG("stream_name: %s\n", smb_fname_str_dbg(stream_name));
1436
1437         status = SMB_VFS_CREATE_FILE(
1438                 ad->ad_handle->conn,            /* conn */
1439                 NULL,                           /* req */
1440                 0,                              /* root_dir_fid */
1441                 stream_name,                    /* fname */
1442                 FILE_GENERIC_WRITE,             /* access_mask */
1443                 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
1444                 FILE_OPEN_IF,                   /* create_disposition */
1445                 0,                              /* create_options */
1446                 0,                              /* file_attributes */
1447                 INTERNAL_OPEN_ONLY,             /* oplock_request */
1448                 NULL,                           /* lease */
1449                 0,                              /* allocation_size */
1450                 0,                              /* private_flags */
1451                 NULL,                           /* sd */
1452                 NULL,                           /* ea_list */
1453                 &fsp,                           /* result */
1454                 NULL,                           /* psbuf */
1455                 NULL, NULL);                    /* create context */
1456         TALLOC_FREE(stream_name);
1457         if (!NT_STATUS_IS_OK(status)) {
1458                 DBG_ERR("SMB_VFS_CREATE_FILE failed\n");
1459                 return -1;
1460         }
1461
1462         nwritten = SMB_VFS_PWRITE(fsp,
1463                                   aiblob.data,
1464                                   aiblob.length,
1465                                   0);
1466         if (nwritten == -1) {
1467                 DBG_ERR("SMB_VFS_PWRITE failed\n");
1468                 saved_errno = errno;
1469                 close_file(NULL, fsp, ERROR_CLOSE);
1470                 errno = saved_errno;
1471                 return -1;
1472         }
1473
1474         status = close_file(NULL, fsp, NORMAL_CLOSE);
1475         if (!NT_STATUS_IS_OK(status)) {
1476                 return -1;
1477         }
1478         fsp = NULL;
1479
1480         return len;
1481 }
1482
1483 /**
1484  * Read and parse resource fork, either ._ AppleDouble file or xattr
1485  **/
1486 static ssize_t ad_read_rsrc(struct adouble *ad,
1487                         const struct smb_filename *smb_fname)
1488 {
1489         struct fruit_config_data *config = NULL;
1490         ssize_t len;
1491
1492         SMB_VFS_HANDLE_GET_DATA(ad->ad_handle, config,
1493                                 struct fruit_config_data, return -1);
1494
1495         if (config->rsrc == FRUIT_RSRC_XATTR) {
1496                 len = ad_read_rsrc_xattr(ad);
1497         } else {
1498                 len = ad_read_rsrc_adouble(ad, smb_fname);
1499         }
1500
1501         return len;
1502 }
1503
1504 /**
1505  * Read and unpack an AppleDouble metadata xattr or resource
1506  **/
1507 static ssize_t ad_read(struct adouble *ad, const struct smb_filename *smb_fname)
1508 {
1509         switch (ad->ad_type) {
1510         case ADOUBLE_META:
1511                 return ad_read_meta(ad, smb_fname);
1512         case ADOUBLE_RSRC:
1513                 return ad_read_rsrc(ad, smb_fname);
1514         default:
1515                 return -1;
1516         }
1517 }
1518
1519 static int adouble_destructor(struct adouble *ad)
1520 {
1521         if ((ad->ad_fd != -1) && ad->ad_opened) {
1522                 close(ad->ad_fd);
1523                 ad->ad_fd = -1;
1524         }
1525         return 0;
1526 }
1527
1528 /**
1529  * Allocate a struct adouble without initialiing it
1530  *
1531  * The struct is either hang of the fsp extension context or if fsp is
1532  * NULL from ctx.
1533  *
1534  * @param[in] ctx        talloc context
1535  * @param[in] handle     vfs handle
1536  * @param[in] type       type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
1537  *
1538  * @return               adouble handle
1539  **/
1540 static struct adouble *ad_alloc(TALLOC_CTX *ctx, vfs_handle_struct *handle,
1541                                 adouble_type_t type)
1542 {
1543         int rc = 0;
1544         size_t adsize = 0;
1545         struct adouble *ad;
1546         struct fruit_config_data *config;
1547
1548         SMB_VFS_HANDLE_GET_DATA(handle, config,
1549                                 struct fruit_config_data, return NULL);
1550
1551         switch (type) {
1552         case ADOUBLE_META:
1553                 adsize = AD_DATASZ_XATTR;
1554                 break;
1555         case ADOUBLE_RSRC:
1556                 if (config->rsrc == FRUIT_RSRC_ADFILE) {
1557                         adsize = AD_DATASZ_DOT_UND;
1558                 }
1559                 break;
1560         default:
1561                 return NULL;
1562         }
1563
1564         ad = talloc_zero(ctx, struct adouble);
1565         if (ad == NULL) {
1566                 rc = -1;
1567                 goto exit;
1568         }
1569
1570         if (adsize) {
1571                 ad->ad_data = talloc_zero_array(ad, char, adsize);
1572                 if (ad->ad_data == NULL) {
1573                         rc = -1;
1574                         goto exit;
1575                 }
1576         }
1577
1578         ad->ad_handle = handle;
1579         ad->ad_type = type;
1580         ad->ad_magic = AD_MAGIC;
1581         ad->ad_version = AD_VERSION;
1582         ad->ad_fd = -1;
1583
1584         talloc_set_destructor(ad, adouble_destructor);
1585
1586 exit:
1587         if (rc != 0) {
1588                 TALLOC_FREE(ad);
1589         }
1590         return ad;
1591 }
1592
1593 /**
1594  * Allocate and initialize a new struct adouble
1595  *
1596  * @param[in] ctx        talloc context
1597  * @param[in] handle     vfs handle
1598  * @param[in] type       type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
1599  *
1600  * @return               adouble handle, initialized
1601  **/
1602 static struct adouble *ad_init(TALLOC_CTX *ctx, vfs_handle_struct *handle,
1603                                adouble_type_t type)
1604 {
1605         int rc = 0;
1606         const struct ad_entry_order  *eid;
1607         struct adouble *ad = NULL;
1608         struct fruit_config_data *config;
1609         time_t t = time(NULL);
1610
1611         SMB_VFS_HANDLE_GET_DATA(handle, config,
1612                                 struct fruit_config_data, return NULL);
1613
1614         switch (type) {
1615         case ADOUBLE_META:
1616                 eid = entry_order_meta_xattr;
1617                 break;
1618         case ADOUBLE_RSRC:
1619                 if (config->rsrc == FRUIT_RSRC_ADFILE) {
1620                         eid = entry_order_dot_und;
1621                 } else {
1622                         eid = entry_order_rsrc_xattr;
1623                 }
1624                 break;
1625         default:
1626                 return NULL;
1627         }
1628
1629         ad = ad_alloc(ctx, handle, type);
1630         if (ad == NULL) {
1631                 return NULL;
1632         }
1633
1634         while (eid->id) {
1635                 ad->ad_eid[eid->id].ade_off = eid->offset;
1636                 ad->ad_eid[eid->id].ade_len = eid->len;
1637                 eid++;
1638         }
1639
1640         /* put something sane in the date fields */
1641         ad_setdate(ad, AD_DATE_CREATE | AD_DATE_UNIX, t);
1642         ad_setdate(ad, AD_DATE_MODIFY | AD_DATE_UNIX, t);
1643         ad_setdate(ad, AD_DATE_ACCESS | AD_DATE_UNIX, t);
1644         ad_setdate(ad, AD_DATE_BACKUP, htonl(AD_DATE_START));
1645
1646         if (rc != 0) {
1647                 TALLOC_FREE(ad);
1648         }
1649         return ad;
1650 }
1651
1652 static struct adouble *ad_get_internal(TALLOC_CTX *ctx,
1653                                        vfs_handle_struct *handle,
1654                                        files_struct *fsp,
1655                                        const struct smb_filename *smb_fname,
1656                                        adouble_type_t type)
1657 {
1658         int rc = 0;
1659         ssize_t len;
1660         struct adouble *ad = NULL;
1661         int mode;
1662
1663         if (fsp != NULL) {
1664                 smb_fname = fsp->base_fsp->fsp_name;
1665         }
1666
1667         DEBUG(10, ("ad_get(%s) called for %s\n",
1668                    type == ADOUBLE_META ? "meta" : "rsrc",
1669                    smb_fname->base_name));
1670
1671         ad = ad_alloc(ctx, handle, type);
1672         if (ad == NULL) {
1673                 rc = -1;
1674                 goto exit;
1675         }
1676
1677         /* Try rw first so we can use the fd in ad_convert() */
1678         mode = O_RDWR;
1679
1680         rc = ad_open(handle, ad, fsp, smb_fname, mode, 0);
1681         if (rc == -1 && ((errno == EROFS) || (errno == EACCES))) {
1682                 mode = O_RDONLY;
1683                 rc = ad_open(handle, ad, fsp, smb_fname, mode, 0);
1684         }
1685         if (rc == -1) {
1686                 DBG_DEBUG("ad_open [%s] error [%s]\n",
1687                           smb_fname->base_name, strerror(errno));
1688                 goto exit;
1689
1690         }
1691
1692         len = ad_read(ad, smb_fname);
1693         if (len == -1) {
1694                 DEBUG(10, ("error reading AppleDouble for %s\n",
1695                         smb_fname->base_name));
1696                 rc = -1;
1697                 goto exit;
1698         }
1699
1700 exit:
1701         DEBUG(10, ("ad_get(%s) for %s returning %d\n",
1702                   type == ADOUBLE_META ? "meta" : "rsrc",
1703                   smb_fname->base_name, rc));
1704
1705         if (rc != 0) {
1706                 TALLOC_FREE(ad);
1707         }
1708         return ad;
1709 }
1710
1711 /**
1712  * Return AppleDouble data for a file
1713  *
1714  * @param[in] ctx      talloc context
1715  * @param[in] handle   vfs handle
1716  * @param[in] smb_fname pathname to file or directory
1717  * @param[in] type     type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
1718  *
1719  * @return             talloced struct adouble or NULL on error
1720  **/
1721 static struct adouble *ad_get(TALLOC_CTX *ctx,
1722                               vfs_handle_struct *handle,
1723                               const struct smb_filename *smb_fname,
1724                               adouble_type_t type)
1725 {
1726         return ad_get_internal(ctx, handle, NULL, smb_fname, type);
1727 }
1728
1729 /**
1730  * Return AppleDouble data for a file
1731  *
1732  * @param[in] ctx      talloc context
1733  * @param[in] handle   vfs handle
1734  * @param[in] fsp      fsp to use for IO
1735  * @param[in] type     type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
1736  *
1737  * @return             talloced struct adouble or NULL on error
1738  **/
1739 static struct adouble *ad_fget(TALLOC_CTX *ctx, vfs_handle_struct *handle,
1740                                files_struct *fsp, adouble_type_t type)
1741 {
1742         return ad_get_internal(ctx, handle, fsp, NULL, type);
1743 }
1744
1745 /**
1746  * Set AppleDouble metadata on a file or directory
1747  *
1748  * @param[in] ad      adouble handle
1749  *
1750  * @param[in] smb_fname    pathname to file or directory
1751  *
1752  * @return            status code, 0 means success
1753  **/
1754 static int ad_set(struct adouble *ad, const struct smb_filename *smb_fname)
1755 {
1756         bool ok;
1757         int ret;
1758
1759         DBG_DEBUG("Path [%s]\n", smb_fname->base_name);
1760
1761         if (ad->ad_type != ADOUBLE_META) {
1762                 DBG_ERR("ad_set on [%s] used with ADOUBLE_RSRC\n",
1763                         smb_fname->base_name);
1764                 return -1;
1765         }
1766
1767         ok = ad_pack(ad);
1768         if (!ok) {
1769                 return -1;
1770         }
1771
1772         ret = SMB_VFS_SETXATTR(ad->ad_handle->conn,
1773                                smb_fname,
1774                                AFPINFO_EA_NETATALK,
1775                                ad->ad_data,
1776                                AD_DATASZ_XATTR, 0);
1777
1778         DBG_DEBUG("Path [%s] ret [%d]\n", smb_fname->base_name, ret);
1779
1780         return ret;
1781 }
1782
1783 /**
1784  * Set AppleDouble metadata on a file or directory
1785  *
1786  * @param[in] ad      adouble handle
1787  * @param[in] fsp     file handle
1788  *
1789  * @return            status code, 0 means success
1790  **/
1791 static int ad_fset(struct adouble *ad, files_struct *fsp)
1792 {
1793         int rc = -1;
1794         ssize_t len;
1795         bool ok;
1796
1797         DBG_DEBUG("Path [%s]\n", fsp_str_dbg(fsp));
1798
1799         if ((fsp == NULL)
1800             || (fsp->fh == NULL)
1801             || (fsp->fh->fd == -1))
1802         {
1803                 smb_panic("bad fsp");
1804         }
1805
1806         ok = ad_pack(ad);
1807         if (!ok) {
1808                 return -1;
1809         }
1810
1811         switch (ad->ad_type) {
1812         case ADOUBLE_META:
1813                 rc = SMB_VFS_NEXT_SETXATTR(ad->ad_handle,
1814                                            fsp->fsp_name,
1815                                            AFPINFO_EA_NETATALK,
1816                                            ad->ad_data,
1817                                            AD_DATASZ_XATTR, 0);
1818                 break;
1819
1820         case ADOUBLE_RSRC:
1821                 len = SMB_VFS_NEXT_PWRITE(ad->ad_handle,
1822                                           fsp,
1823                                           ad->ad_data,
1824                                           AD_DATASZ_DOT_UND,
1825                                           0);
1826                 if (len != AD_DATASZ_DOT_UND) {
1827                         DBG_ERR("short write on %s: %zd", fsp_str_dbg(fsp), len);
1828                         return -1;
1829                 }
1830                 rc = 0;
1831                 break;
1832
1833         default:
1834                 return -1;
1835         }
1836
1837         DBG_DEBUG("Path [%s] rc [%d]\n", fsp_str_dbg(fsp), rc);
1838
1839         return rc;
1840 }
1841
1842 /*****************************************************************************
1843  * Helper functions
1844  *****************************************************************************/
1845
1846 static bool is_afpinfo_stream(const struct smb_filename *smb_fname)
1847 {
1848         if (strncasecmp_m(smb_fname->stream_name,
1849                           AFPINFO_STREAM_NAME,
1850                           strlen(AFPINFO_STREAM_NAME)) == 0) {
1851                 return true;
1852         }
1853         return false;
1854 }
1855
1856 static bool is_afpresource_stream(const struct smb_filename *smb_fname)
1857 {
1858         if (strncasecmp_m(smb_fname->stream_name,
1859                           AFPRESOURCE_STREAM_NAME,
1860                           strlen(AFPRESOURCE_STREAM_NAME)) == 0) {
1861                 return true;
1862         }
1863         return false;
1864 }
1865
1866 /**
1867  * Test whether stream is an Apple stream, not used atm
1868  **/
1869 #if 0
1870 static bool is_apple_stream(const struct smb_filename *smb_fname)
1871 {
1872         if (is_afpinfo_stream(smb_fname)) {
1873                 return true;
1874         }
1875         if (is_afpresource_stream(smb_fname)) {
1876                 return true;
1877         }
1878         return false;
1879 }
1880 #endif
1881
1882 /**
1883  * Initialize config struct from our smb.conf config parameters
1884  **/
1885 static int init_fruit_config(vfs_handle_struct *handle)
1886 {
1887         struct fruit_config_data *config;
1888         int enumval;
1889         const char *tm_size_str = NULL;
1890
1891         config = talloc_zero(handle->conn, struct fruit_config_data);
1892         if (!config) {
1893                 DEBUG(1, ("talloc_zero() failed\n"));
1894                 errno = ENOMEM;
1895                 return -1;
1896         }
1897
1898         /*
1899          * Versions up to Samba 4.5.x had a spelling bug in the
1900          * fruit:resource option calling lp_parm_enum with
1901          * "res*s*ource" (ie two s).
1902          *
1903          * In Samba 4.6 we accept both the wrong and the correct
1904          * spelling, in Samba 4.7 the bad spelling will be removed.
1905          */
1906         enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
1907                                "ressource", fruit_rsrc, FRUIT_RSRC_ADFILE);
1908         if (enumval == -1) {
1909                 DEBUG(1, ("value for %s: resource type unknown\n",
1910                           FRUIT_PARAM_TYPE_NAME));
1911                 return -1;
1912         }
1913         config->rsrc = (enum fruit_rsrc)enumval;
1914
1915         enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
1916                                "resource", fruit_rsrc, enumval);
1917         if (enumval == -1) {
1918                 DEBUG(1, ("value for %s: resource type unknown\n",
1919                           FRUIT_PARAM_TYPE_NAME));
1920                 return -1;
1921         }
1922         config->rsrc = (enum fruit_rsrc)enumval;
1923
1924         enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
1925                                "metadata", fruit_meta, FRUIT_META_NETATALK);
1926         if (enumval == -1) {
1927                 DEBUG(1, ("value for %s: metadata type unknown\n",
1928                           FRUIT_PARAM_TYPE_NAME));
1929                 return -1;
1930         }
1931         config->meta = (enum fruit_meta)enumval;
1932
1933         enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
1934                                "locking", fruit_locking, FRUIT_LOCKING_NONE);
1935         if (enumval == -1) {
1936                 DEBUG(1, ("value for %s: locking type unknown\n",
1937                           FRUIT_PARAM_TYPE_NAME));
1938                 return -1;
1939         }
1940         config->locking = (enum fruit_locking)enumval;
1941
1942         enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
1943                                "encoding", fruit_encoding, FRUIT_ENC_PRIVATE);
1944         if (enumval == -1) {
1945                 DEBUG(1, ("value for %s: encoding type unknown\n",
1946                           FRUIT_PARAM_TYPE_NAME));
1947                 return -1;
1948         }
1949         config->encoding = (enum fruit_encoding)enumval;
1950
1951         if (config->rsrc == FRUIT_RSRC_ADFILE) {
1952                 config->veto_appledouble = lp_parm_bool(SNUM(handle->conn),
1953                                                         FRUIT_PARAM_TYPE_NAME,
1954                                                         "veto_appledouble",
1955                                                         true);
1956         }
1957
1958         config->use_aapl = lp_parm_bool(
1959                 -1, FRUIT_PARAM_TYPE_NAME, "aapl", true);
1960
1961         config->time_machine = lp_parm_bool(
1962                 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME, "time machine", false);
1963
1964         config->unix_info_enabled = lp_parm_bool(
1965                 -1, FRUIT_PARAM_TYPE_NAME, "nfs_aces", true);
1966
1967         config->use_copyfile = lp_parm_bool(-1, FRUIT_PARAM_TYPE_NAME,
1968                                            "copyfile", false);
1969
1970         config->posix_rename = lp_parm_bool(
1971                 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME, "posix_rename", true);
1972
1973         config->aapl_zero_file_id =
1974             lp_parm_bool(-1, FRUIT_PARAM_TYPE_NAME, "zero_file_id", true);
1975
1976         config->readdir_attr_rsize = lp_parm_bool(
1977                 SNUM(handle->conn), "readdir_attr", "aapl_rsize", true);
1978
1979         config->readdir_attr_finder_info = lp_parm_bool(
1980                 SNUM(handle->conn), "readdir_attr", "aapl_finder_info", true);
1981
1982         config->readdir_attr_max_access = lp_parm_bool(
1983                 SNUM(handle->conn), "readdir_attr", "aapl_max_access", true);
1984
1985         config->model = lp_parm_const_string(
1986                 -1, FRUIT_PARAM_TYPE_NAME, "model", "MacSamba");
1987
1988         tm_size_str = lp_parm_const_string(
1989                 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
1990                 "time machine max size", NULL);
1991         if (tm_size_str != NULL) {
1992                 config->time_machine_max_size = conv_str_size(tm_size_str);
1993         }
1994
1995         SMB_VFS_HANDLE_SET_DATA(handle, config,
1996                                 NULL, struct fruit_config_data,
1997                                 return -1);
1998
1999         return 0;
2000 }
2001
2002 /**
2003  * Prepend "._" to a basename
2004  * Return a new struct smb_filename with stream_name == NULL.
2005  **/
2006 static int adouble_path(TALLOC_CTX *ctx,
2007                         const struct smb_filename *smb_fname_in,
2008                         struct smb_filename **pp_smb_fname_out)
2009 {
2010         char *parent;
2011         const char *base;
2012         struct smb_filename *smb_fname = cp_smb_filename(ctx,
2013                                                 smb_fname_in);
2014
2015         if (smb_fname == NULL) {
2016                 return -1;
2017         }
2018
2019         /* We need streamname to be NULL */
2020         TALLOC_FREE(smb_fname->stream_name);
2021
2022         /* And we're replacing base_name. */
2023         TALLOC_FREE(smb_fname->base_name);
2024
2025         if (!parent_dirname(smb_fname, smb_fname_in->base_name,
2026                                 &parent, &base)) {
2027                 TALLOC_FREE(smb_fname);
2028                 return -1;
2029         }
2030
2031         smb_fname->base_name = talloc_asprintf(smb_fname,
2032                                         "%s/._%s", parent, base);
2033         if (smb_fname->base_name == NULL) {
2034                 TALLOC_FREE(smb_fname);
2035                 return -1;
2036         }
2037
2038         *pp_smb_fname_out = smb_fname;
2039
2040         return 0;
2041 }
2042
2043 /**
2044  * Allocate and initialize an AfpInfo struct
2045  **/
2046 static AfpInfo *afpinfo_new(TALLOC_CTX *ctx)
2047 {
2048         AfpInfo *ai = talloc_zero(ctx, AfpInfo);
2049         if (ai == NULL) {
2050                 return NULL;
2051         }
2052         ai->afpi_Signature = AFP_Signature;
2053         ai->afpi_Version = AFP_Version;
2054         ai->afpi_BackupTime = AD_DATE_START;
2055         return ai;
2056 }
2057
2058 /**
2059  * Pack an AfpInfo struct into a buffer
2060  *
2061  * Buffer size must be at least AFP_INFO_SIZE
2062  * Returns size of packed buffer
2063  **/
2064 static ssize_t afpinfo_pack(const AfpInfo *ai, char *buf)
2065 {
2066         memset(buf, 0, AFP_INFO_SIZE);
2067
2068         RSIVAL(buf, 0, ai->afpi_Signature);
2069         RSIVAL(buf, 4, ai->afpi_Version);
2070         RSIVAL(buf, 12, ai->afpi_BackupTime);
2071         memcpy(buf + 16, ai->afpi_FinderInfo, sizeof(ai->afpi_FinderInfo));
2072
2073         return AFP_INFO_SIZE;
2074 }
2075
2076 /**
2077  * Unpack a buffer into a AfpInfo structure
2078  *
2079  * Buffer size must be at least AFP_INFO_SIZE
2080  * Returns allocated AfpInfo struct
2081  **/
2082 static AfpInfo *afpinfo_unpack(TALLOC_CTX *ctx, const void *data)
2083 {
2084         AfpInfo *ai = talloc_zero(ctx, AfpInfo);
2085         if (ai == NULL) {
2086                 return NULL;
2087         }
2088
2089         ai->afpi_Signature = RIVAL(data, 0);
2090         ai->afpi_Version = RIVAL(data, 4);
2091         ai->afpi_BackupTime = RIVAL(data, 12);
2092         memcpy(ai->afpi_FinderInfo, (const char *)data + 16,
2093                sizeof(ai->afpi_FinderInfo));
2094
2095         if (ai->afpi_Signature != AFP_Signature
2096             || ai->afpi_Version != AFP_Version) {
2097                 DEBUG(1, ("Bad AfpInfo signature or version\n"));
2098                 TALLOC_FREE(ai);
2099         }
2100
2101         return ai;
2102 }
2103
2104 /**
2105  * Fake an inode number from the md5 hash of the (xattr) name
2106  **/
2107 static SMB_INO_T fruit_inode(const SMB_STRUCT_STAT *sbuf, const char *sname)
2108 {
2109         MD5_CTX ctx;
2110         unsigned char hash[16];
2111         SMB_INO_T result;
2112         char *upper_sname;
2113
2114         upper_sname = talloc_strdup_upper(talloc_tos(), sname);
2115         SMB_ASSERT(upper_sname != NULL);
2116
2117         MD5Init(&ctx);
2118         MD5Update(&ctx, (const unsigned char *)&(sbuf->st_ex_dev),
2119                   sizeof(sbuf->st_ex_dev));
2120         MD5Update(&ctx, (const unsigned char *)&(sbuf->st_ex_ino),
2121                   sizeof(sbuf->st_ex_ino));
2122         MD5Update(&ctx, (unsigned char *)upper_sname,
2123                   talloc_get_size(upper_sname)-1);
2124         MD5Final(hash, &ctx);
2125
2126         TALLOC_FREE(upper_sname);
2127
2128         /* Hopefully all the variation is in the lower 4 (or 8) bytes! */
2129         memcpy(&result, hash, sizeof(result));
2130
2131         DEBUG(10, ("fruit_inode \"%s\": ino=0x%llu\n",
2132                    sname, (unsigned long long)result));
2133
2134         return result;
2135 }
2136
2137 static bool add_fruit_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
2138                              struct stream_struct **streams,
2139                              const char *name, off_t size,
2140                              off_t alloc_size)
2141 {
2142         struct stream_struct *tmp;
2143
2144         tmp = talloc_realloc(mem_ctx, *streams, struct stream_struct,
2145                              (*num_streams)+1);
2146         if (tmp == NULL) {
2147                 return false;
2148         }
2149
2150         tmp[*num_streams].name = talloc_asprintf(tmp, "%s:$DATA", name);
2151         if (tmp[*num_streams].name == NULL) {
2152                 return false;
2153         }
2154
2155         tmp[*num_streams].size = size;
2156         tmp[*num_streams].alloc_size = alloc_size;
2157
2158         *streams = tmp;
2159         *num_streams += 1;
2160         return true;
2161 }
2162
2163 static bool filter_empty_rsrc_stream(unsigned int *num_streams,
2164                                      struct stream_struct **streams)
2165 {
2166         struct stream_struct *tmp = *streams;
2167         unsigned int i;
2168
2169         if (*num_streams == 0) {
2170                 return true;
2171         }
2172
2173         for (i = 0; i < *num_streams; i++) {
2174                 if (strequal_m(tmp[i].name, AFPRESOURCE_STREAM)) {
2175                         break;
2176                 }
2177         }
2178
2179         if (i == *num_streams) {
2180                 return true;
2181         }
2182
2183         if (tmp[i].size > 0) {
2184                 return true;
2185         }
2186
2187         TALLOC_FREE(tmp[i].name);
2188         if (*num_streams - 1 > i) {
2189                 memmove(&tmp[i], &tmp[i+1],
2190                         (*num_streams - i - 1) * sizeof(struct stream_struct));
2191         }
2192
2193         *num_streams -= 1;
2194         return true;
2195 }
2196
2197 static bool del_fruit_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
2198                              struct stream_struct **streams,
2199                              const char *name)
2200 {
2201         struct stream_struct *tmp = *streams;
2202         unsigned int i;
2203
2204         if (*num_streams == 0) {
2205                 return true;
2206         }
2207
2208         for (i = 0; i < *num_streams; i++) {
2209                 if (strequal_m(tmp[i].name, name)) {
2210                         break;
2211                 }
2212         }
2213
2214         if (i == *num_streams) {
2215                 return true;
2216         }
2217
2218         TALLOC_FREE(tmp[i].name);
2219         if (*num_streams - 1 > i) {
2220                 memmove(&tmp[i], &tmp[i+1],
2221                         (*num_streams - i - 1) * sizeof(struct stream_struct));
2222         }
2223
2224         *num_streams -= 1;
2225         return true;
2226 }
2227
2228 static bool ad_empty_finderinfo(const struct adouble *ad)
2229 {
2230         int cmp;
2231         char emptybuf[ADEDLEN_FINDERI] = {0};
2232         char *fi = NULL;
2233
2234         fi = ad_get_entry(ad, ADEID_FINDERI);
2235         if (fi == NULL) {
2236                 DBG_ERR("Missing FinderInfo in struct adouble [%p]\n", ad);
2237                 return false;
2238         }
2239
2240         cmp = memcmp(emptybuf, fi, ADEDLEN_FINDERI);
2241         return (cmp == 0);
2242 }
2243
2244 static bool ai_empty_finderinfo(const AfpInfo *ai)
2245 {
2246         int cmp;
2247         char emptybuf[ADEDLEN_FINDERI] = {0};
2248
2249         cmp = memcmp(emptybuf, &ai->afpi_FinderInfo[0], ADEDLEN_FINDERI);
2250         return (cmp == 0);
2251 }
2252
2253 /**
2254  * Update btime with btime from Netatalk
2255  **/
2256 static void update_btime(vfs_handle_struct *handle,
2257                          struct smb_filename *smb_fname)
2258 {
2259         uint32_t t;
2260         struct timespec creation_time = {0};
2261         struct adouble *ad;
2262         struct fruit_config_data *config = NULL;
2263
2264         SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
2265                                 return);
2266
2267         switch (config->meta) {
2268         case FRUIT_META_STREAM:
2269                 return;
2270         case FRUIT_META_NETATALK:
2271                 /* Handled below */
2272                 break;
2273         default:
2274                 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
2275                 return;
2276         }
2277
2278         ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_META);
2279         if (ad == NULL) {
2280                 return;
2281         }
2282         if (ad_getdate(ad, AD_DATE_UNIX | AD_DATE_CREATE, &t) != 0) {
2283                 TALLOC_FREE(ad);
2284                 return;
2285         }
2286         TALLOC_FREE(ad);
2287
2288         creation_time.tv_sec = convert_uint32_t_to_time_t(t);
2289         update_stat_ex_create_time(&smb_fname->st, creation_time);
2290
2291         return;
2292 }
2293
2294 /**
2295  * Map an access mask to a Netatalk single byte byte range lock
2296  **/
2297 static off_t access_to_netatalk_brl(enum apple_fork fork_type,
2298                                     uint32_t access_mask)
2299 {
2300         off_t offset;
2301
2302         switch (access_mask) {
2303         case FILE_READ_DATA:
2304                 offset = AD_FILELOCK_OPEN_RD;
2305                 break;
2306
2307         case FILE_WRITE_DATA:
2308         case FILE_APPEND_DATA:
2309                 offset = AD_FILELOCK_OPEN_WR;
2310                 break;
2311
2312         default:
2313                 offset = AD_FILELOCK_OPEN_NONE;
2314                 break;
2315         }
2316
2317         if (fork_type == APPLE_FORK_RSRC) {
2318                 if (offset == AD_FILELOCK_OPEN_NONE) {
2319                         offset = AD_FILELOCK_RSRC_OPEN_NONE;
2320                 } else {
2321                         offset += 2;
2322                 }
2323         }
2324
2325         return offset;
2326 }
2327
2328 /**
2329  * Map a deny mode to a Netatalk brl
2330  **/
2331 static off_t denymode_to_netatalk_brl(enum apple_fork fork_type,
2332                                       uint32_t deny_mode)
2333 {
2334         off_t offset;
2335
2336         switch (deny_mode) {
2337         case DENY_READ:
2338                 offset = AD_FILELOCK_DENY_RD;
2339                 break;
2340
2341         case DENY_WRITE:
2342                 offset = AD_FILELOCK_DENY_WR;
2343                 break;
2344
2345         default:
2346                 smb_panic("denymode_to_netatalk_brl: bad deny mode\n");
2347         }
2348
2349         if (fork_type == APPLE_FORK_RSRC) {
2350                 offset += 2;
2351         }
2352
2353         return offset;
2354 }
2355
2356 /**
2357  * Call fcntl() with an exclusive F_GETLK request in order to
2358  * determine if there's an exisiting shared lock
2359  *
2360  * @return true if the requested lock was found or any error occurred
2361  *         false if the lock was not found
2362  **/
2363 static bool test_netatalk_lock(files_struct *fsp, off_t in_offset)
2364 {
2365         bool result;
2366         off_t offset = in_offset;
2367         off_t len = 1;
2368         int type = F_WRLCK;
2369         pid_t pid;
2370
2371         result = SMB_VFS_GETLOCK(fsp, &offset, &len, &type, &pid);
2372         if (result == false) {
2373                 return true;
2374         }
2375
2376         if (type != F_UNLCK) {
2377                 return true;
2378         }
2379
2380         return false;
2381 }
2382
2383 static NTSTATUS fruit_check_access(vfs_handle_struct *handle,
2384                                    files_struct *fsp,
2385                                    uint32_t access_mask,
2386                                    uint32_t deny_mode)
2387 {
2388         NTSTATUS status = NT_STATUS_OK;
2389         struct byte_range_lock *br_lck = NULL;
2390         bool open_for_reading, open_for_writing, deny_read, deny_write;
2391         off_t off;
2392         bool have_read = false;
2393         int flags;
2394
2395         /* FIXME: hardcoded data fork, add resource fork */
2396         enum apple_fork fork_type = APPLE_FORK_DATA;
2397
2398         DEBUG(10, ("fruit_check_access: %s, am: %s/%s, dm: %s/%s\n",
2399                   fsp_str_dbg(fsp),
2400                   access_mask & FILE_READ_DATA ? "READ" :"-",
2401                   access_mask & FILE_WRITE_DATA ? "WRITE" : "-",
2402                   deny_mode & DENY_READ ? "DENY_READ" : "-",
2403                   deny_mode & DENY_WRITE ? "DENY_WRITE" : "-"));
2404
2405         if (fsp->fh->fd == -1) {
2406                 return NT_STATUS_OK;
2407         }
2408
2409         flags = fcntl(fsp->fh->fd, F_GETFL);
2410         if (flags == -1) {
2411                 DBG_ERR("fcntl get flags [%s] fd [%d] failed [%s]\n",
2412                         fsp_str_dbg(fsp), fsp->fh->fd, strerror(errno));
2413                 return map_nt_error_from_unix(errno);
2414         }
2415
2416         if (flags & (O_RDONLY|O_RDWR)) {
2417                 /*
2418                  * Applying fcntl read locks requires an fd opened for
2419                  * reading. This means we won't be applying locks for
2420                  * files openend write-only, but what can we do...
2421                  */
2422                 have_read = true;
2423         }
2424
2425         /*
2426          * Check read access and deny read mode
2427          */
2428         if ((access_mask & FILE_READ_DATA) || (deny_mode & DENY_READ)) {
2429                 /* Check access */
2430                 open_for_reading = test_netatalk_lock(
2431                         fsp, access_to_netatalk_brl(fork_type, FILE_READ_DATA));
2432
2433                 deny_read = test_netatalk_lock(
2434                         fsp, denymode_to_netatalk_brl(fork_type, DENY_READ));
2435
2436                 DEBUG(10, ("read: %s, deny_write: %s\n",
2437                           open_for_reading == true ? "yes" : "no",
2438                           deny_read == true ? "yes" : "no"));
2439
2440                 if (((access_mask & FILE_READ_DATA) && deny_read)
2441                     || ((deny_mode & DENY_READ) && open_for_reading)) {
2442                         return NT_STATUS_SHARING_VIOLATION;
2443                 }
2444
2445                 /* Set locks */
2446                 if ((access_mask & FILE_READ_DATA) && have_read) {
2447                         off = access_to_netatalk_brl(fork_type, FILE_READ_DATA);
2448                         br_lck = do_lock(
2449                                 handle->conn->sconn->msg_ctx, fsp,
2450                                 fsp->op->global->open_persistent_id, 1, off,
2451                                 READ_LOCK, POSIX_LOCK, false,
2452                                 &status, NULL);
2453
2454                         if (!NT_STATUS_IS_OK(status))  {
2455                                 return status;
2456                         }
2457                         TALLOC_FREE(br_lck);
2458                 }
2459
2460                 if ((deny_mode & DENY_READ) && have_read) {
2461                         off = denymode_to_netatalk_brl(fork_type, DENY_READ);
2462                         br_lck = do_lock(
2463                                 handle->conn->sconn->msg_ctx, fsp,
2464                                 fsp->op->global->open_persistent_id, 1, off,
2465                                 READ_LOCK, POSIX_LOCK, false,
2466                                 &status, NULL);
2467
2468                         if (!NT_STATUS_IS_OK(status)) {
2469                                 return status;
2470                         }
2471                         TALLOC_FREE(br_lck);
2472                 }
2473         }
2474
2475         /*
2476          * Check write access and deny write mode
2477          */
2478         if ((access_mask & FILE_WRITE_DATA) || (deny_mode & DENY_WRITE)) {
2479                 /* Check access */
2480                 open_for_writing = test_netatalk_lock(
2481                         fsp, access_to_netatalk_brl(fork_type, FILE_WRITE_DATA));
2482
2483                 deny_write = test_netatalk_lock(
2484                         fsp, denymode_to_netatalk_brl(fork_type, DENY_WRITE));
2485
2486                 DEBUG(10, ("write: %s, deny_write: %s\n",
2487                           open_for_writing == true ? "yes" : "no",
2488                           deny_write == true ? "yes" : "no"));
2489
2490                 if (((access_mask & FILE_WRITE_DATA) && deny_write)
2491                     || ((deny_mode & DENY_WRITE) && open_for_writing)) {
2492                         return NT_STATUS_SHARING_VIOLATION;
2493                 }
2494
2495                 /* Set locks */
2496                 if ((access_mask & FILE_WRITE_DATA) && have_read) {
2497                         off = access_to_netatalk_brl(fork_type, FILE_WRITE_DATA);
2498                         br_lck = do_lock(
2499                                 handle->conn->sconn->msg_ctx, fsp,
2500                                 fsp->op->global->open_persistent_id, 1, off,
2501                                 READ_LOCK, POSIX_LOCK, false,
2502                                 &status, NULL);
2503
2504                         if (!NT_STATUS_IS_OK(status)) {
2505                                 return status;
2506                         }
2507                         TALLOC_FREE(br_lck);
2508
2509                 }
2510                 if ((deny_mode & DENY_WRITE) && have_read) {
2511                         off = denymode_to_netatalk_brl(fork_type, DENY_WRITE);
2512                         br_lck = do_lock(
2513                                 handle->conn->sconn->msg_ctx, fsp,
2514                                 fsp->op->global->open_persistent_id, 1, off,
2515                                 READ_LOCK, POSIX_LOCK, false,
2516                                 &status, NULL);
2517
2518                         if (!NT_STATUS_IS_OK(status)) {
2519                                 return status;
2520                         }
2521                         TALLOC_FREE(br_lck);
2522                 }
2523         }
2524
2525         TALLOC_FREE(br_lck);
2526
2527         return status;
2528 }
2529
2530 static NTSTATUS check_aapl(vfs_handle_struct *handle,
2531                            struct smb_request *req,
2532                            const struct smb2_create_blobs *in_context_blobs,
2533                            struct smb2_create_blobs *out_context_blobs)
2534 {
2535         struct fruit_config_data *config;
2536         NTSTATUS status;
2537         struct smb2_create_blob *aapl = NULL;
2538         uint32_t cmd;
2539         bool ok;
2540         uint8_t p[16];
2541         DATA_BLOB blob = data_blob_talloc(req, NULL, 0);
2542         uint64_t req_bitmap, client_caps;
2543         uint64_t server_caps = SMB2_CRTCTX_AAPL_UNIX_BASED;
2544         smb_ucs2_t *model;
2545         size_t modellen;
2546
2547         SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
2548                                 return NT_STATUS_UNSUCCESSFUL);
2549
2550         if (!config->use_aapl
2551             || in_context_blobs == NULL
2552             || out_context_blobs == NULL) {
2553                 return NT_STATUS_OK;
2554         }
2555
2556         aapl = smb2_create_blob_find(in_context_blobs,
2557                                      SMB2_CREATE_TAG_AAPL);
2558         if (aapl == NULL) {
2559                 return NT_STATUS_OK;
2560         }
2561
2562         if (aapl->data.length != 24) {
2563                 DEBUG(1, ("unexpected AAPL ctxt length: %ju\n",
2564                           (uintmax_t)aapl->data.length));
2565                 return NT_STATUS_INVALID_PARAMETER;
2566         }
2567
2568         cmd = IVAL(aapl->data.data, 0);
2569         if (cmd != SMB2_CRTCTX_AAPL_SERVER_QUERY) {
2570                 DEBUG(1, ("unsupported AAPL cmd: %d\n", cmd));
2571                 return NT_STATUS_INVALID_PARAMETER;
2572         }
2573
2574         req_bitmap = BVAL(aapl->data.data, 8);
2575         client_caps = BVAL(aapl->data.data, 16);
2576
2577         SIVAL(p, 0, SMB2_CRTCTX_AAPL_SERVER_QUERY);
2578         SIVAL(p, 4, 0);
2579         SBVAL(p, 8, req_bitmap);
2580         ok = data_blob_append(req, &blob, p, 16);
2581         if (!ok) {
2582                 return NT_STATUS_UNSUCCESSFUL;
2583         }
2584
2585         if (req_bitmap & SMB2_CRTCTX_AAPL_SERVER_CAPS) {
2586                 if ((client_caps & SMB2_CRTCTX_AAPL_SUPPORTS_READ_DIR_ATTR) &&
2587                     (handle->conn->tcon->compat->fs_capabilities & FILE_NAMED_STREAMS)) {
2588                         server_caps |= SMB2_CRTCTX_AAPL_SUPPORTS_READ_DIR_ATTR;
2589                         config->readdir_attr_enabled = true;
2590                 }
2591
2592                 if (config->use_copyfile) {
2593                         server_caps |= SMB2_CRTCTX_AAPL_SUPPORTS_OSX_COPYFILE;
2594                         config->copyfile_enabled = true;
2595                 }
2596
2597                 /*
2598                  * The client doesn't set the flag, so we can't check
2599                  * for it and just set it unconditionally
2600                  */
2601                 if (config->unix_info_enabled) {
2602                         server_caps |= SMB2_CRTCTX_AAPL_SUPPORTS_NFS_ACE;
2603                 }
2604
2605                 SBVAL(p, 0, server_caps);
2606                 ok = data_blob_append(req, &blob, p, 8);
2607                 if (!ok) {
2608                         return NT_STATUS_UNSUCCESSFUL;
2609                 }
2610         }
2611
2612         if (req_bitmap & SMB2_CRTCTX_AAPL_VOLUME_CAPS) {
2613                 int val = lp_case_sensitive(SNUM(handle->conn->tcon->compat));
2614                 uint64_t caps = 0;
2615
2616                 switch (val) {
2617                 case Auto:
2618                         break;
2619
2620                 case True:
2621                         caps |= SMB2_CRTCTX_AAPL_CASE_SENSITIVE;
2622                         break;
2623
2624                 default:
2625                         break;
2626                 }
2627
2628                 if (config->time_machine) {
2629                         caps |= SMB2_CRTCTX_AAPL_FULL_SYNC;
2630                 }
2631
2632                 SBVAL(p, 0, caps);
2633
2634                 ok = data_blob_append(req, &blob, p, 8);
2635                 if (!ok) {
2636                         return NT_STATUS_UNSUCCESSFUL;
2637                 }
2638         }
2639
2640         if (req_bitmap & SMB2_CRTCTX_AAPL_MODEL_INFO) {
2641                 ok = convert_string_talloc(req,
2642                                            CH_UNIX, CH_UTF16LE,
2643                                            config->model, strlen(config->model),
2644                                            &model, &modellen);
2645                 if (!ok) {
2646                         return NT_STATUS_UNSUCCESSFUL;
2647                 }
2648
2649                 SIVAL(p, 0, 0);
2650                 SIVAL(p + 4, 0, modellen);
2651                 ok = data_blob_append(req, &blob, p, 8);
2652                 if (!ok) {
2653                         talloc_free(model);
2654                         return NT_STATUS_UNSUCCESSFUL;
2655                 }
2656
2657                 ok = data_blob_append(req, &blob, model, modellen);
2658                 talloc_free(model);
2659                 if (!ok) {
2660                         return NT_STATUS_UNSUCCESSFUL;
2661                 }
2662         }
2663
2664         status = smb2_create_blob_add(out_context_blobs,
2665                                       out_context_blobs,
2666                                       SMB2_CREATE_TAG_AAPL,
2667                                       blob);
2668         if (NT_STATUS_IS_OK(status)) {
2669                 global_fruit_config.nego_aapl = true;
2670                 if (config->aapl_zero_file_id) {
2671                         aapl_force_zero_file_id(handle->conn->sconn);
2672                 }
2673         }
2674
2675         return status;
2676 }
2677
2678 static bool readdir_attr_meta_finderi_stream(
2679         struct vfs_handle_struct *handle,
2680         const struct smb_filename *smb_fname,
2681         AfpInfo *ai)
2682 {
2683         struct smb_filename *stream_name = NULL;
2684         files_struct *fsp = NULL;
2685         ssize_t nread;
2686         NTSTATUS status;
2687         int ret;
2688         bool ok;
2689         uint8_t buf[AFP_INFO_SIZE];
2690
2691         stream_name = synthetic_smb_fname(talloc_tos(),
2692                                           smb_fname->base_name,
2693                                           AFPINFO_STREAM_NAME,
2694                                           NULL, smb_fname->flags);
2695         if (stream_name == NULL) {
2696                 return false;
2697         }
2698
2699         ret = SMB_VFS_STAT(handle->conn, stream_name);
2700         if (ret != 0) {
2701                 return false;
2702         }
2703
2704         status = SMB_VFS_CREATE_FILE(
2705                 handle->conn,                           /* conn */
2706                 NULL,                                   /* req */
2707                 0,                                      /* root_dir_fid */
2708                 stream_name,                            /* fname */
2709                 FILE_READ_DATA,                         /* access_mask */
2710                 (FILE_SHARE_READ | FILE_SHARE_WRITE |   /* share_access */
2711                         FILE_SHARE_DELETE),
2712                 FILE_OPEN,                              /* create_disposition*/
2713                 0,                                      /* create_options */
2714                 0,                                      /* file_attributes */
2715                 INTERNAL_OPEN_ONLY,                     /* oplock_request */
2716                 NULL,                                   /* lease */
2717                 0,                                      /* allocation_size */
2718                 0,                                      /* private_flags */
2719                 NULL,                                   /* sd */
2720                 NULL,                                   /* ea_list */
2721                 &fsp,                                   /* result */
2722                 NULL,                                   /* pinfo */
2723                 NULL, NULL);                            /* create context */
2724
2725         TALLOC_FREE(stream_name);
2726
2727         if (!NT_STATUS_IS_OK(status)) {
2728                 return false;
2729         }
2730
2731         nread = SMB_VFS_PREAD(fsp, &buf[0], AFP_INFO_SIZE, 0);
2732         if (nread != AFP_INFO_SIZE) {
2733                 DBG_ERR("short read [%s] [%zd/%d]\n",
2734                         smb_fname_str_dbg(stream_name), nread, AFP_INFO_SIZE);
2735                 ok = false;
2736                 goto fail;
2737         }
2738
2739         memcpy(&ai->afpi_FinderInfo[0], &buf[AFP_OFF_FinderInfo],
2740                AFP_FinderSize);
2741
2742         ok = true;
2743
2744 fail:
2745         if (fsp != NULL) {
2746                 close_file(NULL, fsp, NORMAL_CLOSE);
2747         }
2748
2749         return ok;
2750 }
2751
2752 static bool readdir_attr_meta_finderi_netatalk(
2753         struct vfs_handle_struct *handle,
2754         const struct smb_filename *smb_fname,
2755         AfpInfo *ai)
2756 {
2757         struct adouble *ad = NULL;
2758         char *p = NULL;
2759
2760         ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_META);
2761         if (ad == NULL) {
2762                 return false;
2763         }
2764
2765         p = ad_get_entry(ad, ADEID_FINDERI);
2766         if (p == NULL) {
2767                 DBG_ERR("No ADEID_FINDERI for [%s]\n", smb_fname->base_name);
2768                 TALLOC_FREE(ad);
2769                 return false;
2770         }
2771
2772         memcpy(&ai->afpi_FinderInfo[0], p, AFP_FinderSize);
2773         TALLOC_FREE(ad);
2774         return true;
2775 }
2776
2777 static bool readdir_attr_meta_finderi(struct vfs_handle_struct *handle,
2778                                       const struct smb_filename *smb_fname,
2779                                       struct readdir_attr_data *attr_data)
2780 {
2781         struct fruit_config_data *config = NULL;
2782         uint32_t date_added;
2783         AfpInfo ai = {0};
2784         bool ok;
2785
2786         SMB_VFS_HANDLE_GET_DATA(handle, config,
2787                                 struct fruit_config_data,
2788                                 return false);
2789
2790         switch (config->meta) {
2791         case FRUIT_META_NETATALK:
2792                 ok = readdir_attr_meta_finderi_netatalk(
2793                         handle, smb_fname, &ai);
2794                 break;
2795
2796         case FRUIT_META_STREAM:
2797                 ok = readdir_attr_meta_finderi_stream(
2798                         handle, smb_fname, &ai);
2799                 break;
2800
2801         default:
2802                 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
2803                 return false;
2804         }
2805
2806         if (!ok) {
2807                 /* Don't bother with errors, it's likely ENOENT */
2808                 return true;
2809         }
2810
2811         if (S_ISREG(smb_fname->st.st_ex_mode)) {
2812                 /* finder_type */
2813                 memcpy(&attr_data->attr_data.aapl.finder_info[0],
2814                        &ai.afpi_FinderInfo[0], 4);
2815
2816                 /* finder_creator */
2817                 memcpy(&attr_data->attr_data.aapl.finder_info[0] + 4,
2818                        &ai.afpi_FinderInfo[4], 4);
2819         }
2820
2821         /* finder_flags */
2822         memcpy(&attr_data->attr_data.aapl.finder_info[0] + 8,
2823                &ai.afpi_FinderInfo[8], 2);
2824
2825         /* finder_ext_flags */
2826         memcpy(&attr_data->attr_data.aapl.finder_info[0] + 10,
2827                &ai.afpi_FinderInfo[24], 2);
2828
2829         /* creation date */
2830         date_added = convert_time_t_to_uint32_t(
2831                 smb_fname->st.st_ex_btime.tv_sec - AD_DATE_DELTA);
2832
2833         RSIVAL(&attr_data->attr_data.aapl.finder_info[0], 12, date_added);
2834
2835         return true;
2836 }
2837
2838 static uint64_t readdir_attr_rfork_size_adouble(
2839         struct vfs_handle_struct *handle,
2840         const struct smb_filename *smb_fname)
2841 {
2842         struct adouble *ad = NULL;
2843         uint64_t rfork_size;
2844
2845         ad = ad_get(talloc_tos(), handle, smb_fname,
2846                     ADOUBLE_RSRC);
2847         if (ad == NULL) {
2848                 return 0;
2849         }
2850
2851         rfork_size = ad_getentrylen(ad, ADEID_RFORK);
2852         TALLOC_FREE(ad);
2853
2854         return rfork_size;
2855 }
2856
2857 static uint64_t readdir_attr_rfork_size_stream(
2858         struct vfs_handle_struct *handle,
2859         const struct smb_filename *smb_fname)
2860 {
2861         struct smb_filename *stream_name = NULL;
2862         int ret;
2863         uint64_t rfork_size;
2864
2865         stream_name = synthetic_smb_fname(talloc_tos(),
2866                                           smb_fname->base_name,
2867                                           AFPRESOURCE_STREAM_NAME,
2868                                           NULL, 0);
2869         if (stream_name == NULL) {
2870                 return 0;
2871         }
2872
2873         ret = SMB_VFS_STAT(handle->conn, stream_name);
2874         if (ret != 0) {
2875                 TALLOC_FREE(stream_name);
2876                 return 0;
2877         }
2878
2879         rfork_size = stream_name->st.st_ex_size;
2880         TALLOC_FREE(stream_name);
2881
2882         return rfork_size;
2883 }
2884
2885 static uint64_t readdir_attr_rfork_size(struct vfs_handle_struct *handle,
2886                                         const struct smb_filename *smb_fname)
2887 {
2888         struct fruit_config_data *config = NULL;
2889         uint64_t rfork_size;
2890
2891         SMB_VFS_HANDLE_GET_DATA(handle, config,
2892                                 struct fruit_config_data,
2893                                 return 0);
2894
2895         switch (config->rsrc) {
2896         case FRUIT_RSRC_ADFILE:
2897         case FRUIT_RSRC_XATTR:
2898                 rfork_size = readdir_attr_rfork_size_adouble(handle,
2899                                                              smb_fname);
2900                 break;
2901
2902         case FRUIT_META_STREAM:
2903                 rfork_size = readdir_attr_rfork_size_stream(handle,
2904                                                             smb_fname);
2905                 break;
2906
2907         default:
2908                 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
2909                 rfork_size = 0;
2910                 break;
2911         }
2912
2913         return rfork_size;
2914 }
2915
2916 static NTSTATUS readdir_attr_macmeta(struct vfs_handle_struct *handle,
2917                                      const struct smb_filename *smb_fname,
2918                                      struct readdir_attr_data *attr_data)
2919 {
2920         NTSTATUS status = NT_STATUS_OK;
2921         struct fruit_config_data *config = NULL;
2922         bool ok;
2923
2924         SMB_VFS_HANDLE_GET_DATA(handle, config,
2925                                 struct fruit_config_data,
2926                                 return NT_STATUS_UNSUCCESSFUL);
2927
2928
2929         /* Ensure we return a default value in the creation_date field */
2930         RSIVAL(&attr_data->attr_data.aapl.finder_info, 12, AD_DATE_START);
2931
2932         /*
2933          * Resource fork length
2934          */
2935
2936         if (config->readdir_attr_rsize) {
2937                 uint64_t rfork_size;
2938
2939                 rfork_size = readdir_attr_rfork_size(handle, smb_fname);
2940                 attr_data->attr_data.aapl.rfork_size = rfork_size;
2941         }
2942
2943         /*
2944          * FinderInfo
2945          */
2946
2947         if (config->readdir_attr_finder_info) {
2948                 ok = readdir_attr_meta_finderi(handle, smb_fname, attr_data);
2949                 if (!ok) {
2950                         status = NT_STATUS_INTERNAL_ERROR;
2951                 }
2952         }
2953
2954         return status;
2955 }
2956
2957 /* Search MS NFS style ACE with UNIX mode */
2958 static NTSTATUS check_ms_nfs(vfs_handle_struct *handle,
2959                              files_struct *fsp,
2960                              struct security_descriptor *psd,
2961                              mode_t *pmode,
2962                              bool *pdo_chmod)
2963 {
2964         uint32_t i;
2965         struct fruit_config_data *config = NULL;
2966         struct dom_sid sid;
2967         NTSTATUS status = NT_STATUS_OK;
2968         bool remove_ok = false;
2969
2970         *pdo_chmod = false;
2971
2972         SMB_VFS_HANDLE_GET_DATA(handle, config,
2973                                 struct fruit_config_data,
2974                                 return NT_STATUS_UNSUCCESSFUL);
2975
2976         if (!global_fruit_config.nego_aapl) {
2977                 return NT_STATUS_OK;
2978         }
2979         if (psd->dacl == NULL || !config->unix_info_enabled) {
2980                 return NT_STATUS_OK;
2981         }
2982
2983         for (i = 0; i < psd->dacl->num_aces; i++) {
2984                 if (dom_sid_compare_domain(
2985                             &global_sid_Unix_NFS_Mode,
2986                             &psd->dacl->aces[i].trustee) == 0) {
2987                         *pmode = (mode_t)psd->dacl->aces[i].trustee.sub_auths[2];
2988                         *pmode &= (S_IRWXU | S_IRWXG | S_IRWXO);
2989                         *pdo_chmod = true;
2990
2991                         DEBUG(10, ("MS NFS chmod request %s, %04o\n",
2992                                    fsp_str_dbg(fsp), (unsigned)(*pmode)));
2993                         break;
2994                 }
2995         }
2996
2997         /*
2998          * Remove any incoming virtual ACE entries generated by
2999          * fruit_fget_nt_acl().
3000          */
3001
3002         /* MS NFS style mode */
3003         sid_compose(&sid, &global_sid_Unix_NFS_Mode,
3004                     fsp->fsp_name->st.st_ex_mode);
3005         status = security_descriptor_dacl_del(psd, &sid);
3006         remove_ok = (NT_STATUS_IS_OK(status) ||
3007                      NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND));
3008         if (!remove_ok) {
3009                 DBG_WARNING("failed to remove MS NFS_mode style ACE\n");
3010                 return status;
3011         }
3012
3013         /* MS NFS style uid */
3014         sid_compose(&sid, &global_sid_Unix_NFS_Users,
3015                     fsp->fsp_name->st.st_ex_uid);
3016         status = security_descriptor_dacl_del(psd, &sid);
3017         remove_ok = (NT_STATUS_IS_OK(status) ||
3018                      NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND));
3019         if (!remove_ok) {
3020                 DBG_WARNING("failed to remove MS NFS_users style ACE\n");
3021                 return status;
3022         }
3023
3024         /* MS NFS style gid */
3025         sid_compose(&sid, &global_sid_Unix_NFS_Groups,
3026                     fsp->fsp_name->st.st_ex_gid);
3027         status = security_descriptor_dacl_del(psd, &sid);
3028         remove_ok = (NT_STATUS_IS_OK(status) ||
3029                      NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND));
3030         if (!remove_ok) {
3031                 DBG_WARNING("failed to remove MS NFS_groups style ACE\n");
3032                 return status;
3033         }
3034
3035         return NT_STATUS_OK;
3036 }
3037
3038 /****************************************************************************
3039  * VFS ops
3040  ****************************************************************************/
3041
3042 static int fruit_connect(vfs_handle_struct *handle,
3043                          const char *service,
3044                          const char *user)
3045 {
3046         int rc;
3047         char *list = NULL, *newlist = NULL;
3048         struct fruit_config_data *config;
3049
3050         DEBUG(10, ("fruit_connect\n"));
3051
3052         rc = SMB_VFS_NEXT_CONNECT(handle, service, user);
3053         if (rc < 0) {
3054                 return rc;
3055         }
3056
3057         rc = init_fruit_config(handle);
3058         if (rc != 0) {
3059                 return rc;
3060         }
3061
3062         SMB_VFS_HANDLE_GET_DATA(handle, config,
3063                                 struct fruit_config_data, return -1);
3064
3065         if (config->veto_appledouble) {
3066                 list = lp_veto_files(talloc_tos(), SNUM(handle->conn));
3067
3068                 if (list) {
3069                         if (strstr(list, "/" ADOUBLE_NAME_PREFIX "*/") == NULL) {
3070                                 newlist = talloc_asprintf(
3071                                         list,
3072                                         "%s/" ADOUBLE_NAME_PREFIX "*/",
3073                                         list);
3074                                 lp_do_parameter(SNUM(handle->conn),
3075                                                 "veto files",
3076                                                 newlist);
3077                         }
3078                 } else {
3079                         lp_do_parameter(SNUM(handle->conn),
3080                                         "veto files",
3081                                         "/" ADOUBLE_NAME_PREFIX "*/");
3082                 }
3083
3084                 TALLOC_FREE(list);
3085         }
3086
3087         if (config->encoding == FRUIT_ENC_NATIVE) {
3088                 lp_do_parameter(SNUM(handle->conn),
3089                                 "catia:mappings",
3090                                 fruit_catia_maps);
3091         }
3092
3093         if (config->time_machine) {
3094                 DBG_NOTICE("Enabling durable handles for Time Machine "
3095                            "support on [%s]\n", service);
3096                 lp_do_parameter(SNUM(handle->conn), "durable handles", "yes");
3097                 lp_do_parameter(SNUM(handle->conn), "kernel oplocks", "no");
3098                 lp_do_parameter(SNUM(handle->conn), "kernel share modes", "no");
3099                 if (!lp_strict_sync(SNUM(handle->conn))) {
3100                         DBG_WARNING("Time Machine without strict sync is not "
3101                                     "recommended!\n");
3102                 }
3103                 lp_do_parameter(SNUM(handle->conn), "posix locking", "no");
3104         }
3105
3106         return rc;
3107 }
3108
3109 static int fruit_open_meta_stream(vfs_handle_struct *handle,
3110                                   struct smb_filename *smb_fname,
3111                                   files_struct *fsp,
3112                                   int flags,
3113                                   mode_t mode)
3114 {
3115         AfpInfo *ai = NULL;
3116         char afpinfo_buf[AFP_INFO_SIZE];
3117         ssize_t len, written;
3118         int hostfd = -1;
3119         int rc = -1;
3120
3121         hostfd = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
3122         if (hostfd == -1) {
3123                 return -1;
3124         }
3125
3126         if (!(flags & (O_CREAT | O_TRUNC))) {
3127                 return hostfd;
3128         }
3129
3130         ai = afpinfo_new(talloc_tos());
3131         if (ai == NULL) {
3132                 rc = -1;
3133                 goto fail;
3134         }
3135
3136         len = afpinfo_pack(ai, afpinfo_buf);
3137         if (len != AFP_INFO_SIZE) {
3138                 rc = -1;
3139                 goto fail;
3140         }
3141
3142         /* Set fd, needed in SMB_VFS_NEXT_PWRITE() */
3143         fsp->fh->fd = hostfd;
3144
3145         written = SMB_VFS_NEXT_PWRITE(handle, fsp, afpinfo_buf,
3146                                       AFP_INFO_SIZE, 0);
3147         fsp->fh->fd = -1;
3148         if (written != AFP_INFO_SIZE) {
3149                 DBG_ERR("bad write [%zd/%d]\n", written, AFP_INFO_SIZE);
3150                 rc = -1;
3151                 goto fail;
3152         }
3153
3154         rc = 0;
3155
3156 fail:
3157         DBG_DEBUG("rc=%d, fd=%d\n", rc, hostfd);
3158
3159         if (rc != 0) {
3160                 int saved_errno = errno;
3161                 if (hostfd >= 0) {
3162                         fsp->fh->fd = hostfd;
3163                         SMB_VFS_NEXT_CLOSE(handle, fsp);
3164                 }
3165                 hostfd = -1;
3166                 errno = saved_errno;
3167         }
3168         return hostfd;
3169 }
3170
3171 static int fruit_open_meta_netatalk(vfs_handle_struct *handle,
3172                                     struct smb_filename *smb_fname,
3173                                     files_struct *fsp,
3174                                     int flags,
3175                                     mode_t mode)
3176 {
3177         int rc;
3178         int fakefd = -1;
3179         struct adouble *ad = NULL;
3180         int fds[2];
3181
3182         DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
3183
3184         /*
3185          * Return a valid fd, but ensure any attempt to use it returns an error
3186          * (EPIPE). All operations on the smb_fname or the fsp will use path
3187          * based syscalls.
3188          */
3189         rc = pipe(fds);
3190         if (rc != 0) {
3191                 goto exit;
3192         }
3193         fakefd = fds[0];
3194         close(fds[1]);
3195
3196         if (flags & (O_CREAT | O_TRUNC)) {
3197                 /*
3198                  * The attribute does not exist or needs to be truncated,
3199                  * create an AppleDouble EA
3200                  */
3201                 ad = ad_init(fsp, handle, ADOUBLE_META);
3202                 if (ad == NULL) {
3203                         rc = -1;
3204                         goto exit;
3205                 }
3206
3207                 rc = ad_set(ad, fsp->fsp_name);
3208                 if (rc != 0) {
3209                         rc = -1;
3210                         goto exit;
3211                 }
3212
3213                 TALLOC_FREE(ad);
3214         }
3215
3216 exit:
3217         DEBUG(10, ("fruit_open meta rc=%d, fd=%d\n", rc, fakefd));
3218         if (rc != 0) {
3219                 int saved_errno = errno;
3220                 if (fakefd >= 0) {
3221                         close(fakefd);
3222                 }
3223                 fakefd = -1;
3224                 errno = saved_errno;
3225         }
3226         return fakefd;
3227 }
3228
3229 static int fruit_open_meta(vfs_handle_struct *handle,
3230                            struct smb_filename *smb_fname,
3231                            files_struct *fsp, int flags, mode_t mode)
3232 {
3233         int fd;
3234         struct fruit_config_data *config = NULL;
3235         struct fio *fio = NULL;
3236
3237         DBG_DEBUG("path [%s]\n", smb_fname_str_dbg(smb_fname));
3238
3239         SMB_VFS_HANDLE_GET_DATA(handle, config,
3240                                 struct fruit_config_data, return -1);
3241
3242         switch (config->meta) {
3243         case FRUIT_META_STREAM:
3244                 fd = fruit_open_meta_stream(handle, smb_fname,
3245                                             fsp, flags, mode);
3246                 break;
3247
3248         case FRUIT_META_NETATALK:
3249                 fd = fruit_open_meta_netatalk(handle, smb_fname,
3250                                               fsp, flags, mode);
3251                 break;
3252
3253         default:
3254                 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
3255                 return -1;
3256         }
3257
3258         DBG_DEBUG("path [%s] fd [%d]\n", smb_fname_str_dbg(smb_fname), fd);
3259
3260         if (fd == -1) {
3261                 return -1;
3262         }
3263
3264         fio = VFS_ADD_FSP_EXTENSION(handle, fsp, struct fio, NULL);
3265         fio->type = ADOUBLE_META;
3266         fio->config = config;
3267
3268         return fd;
3269 }
3270
3271 static int fruit_open_rsrc_adouble(vfs_handle_struct *handle,
3272                                    struct smb_filename *smb_fname,
3273                                    files_struct *fsp,
3274                                    int flags,
3275                                    mode_t mode)
3276 {
3277         int rc = 0;
3278         struct adouble *ad = NULL;
3279         struct smb_filename *smb_fname_base = NULL;
3280         struct fruit_config_data *config = NULL;
3281         int hostfd = -1;
3282
3283         SMB_VFS_HANDLE_GET_DATA(handle, config,
3284                                 struct fruit_config_data, return -1);
3285
3286         if ((!(flags & O_CREAT)) &&
3287             S_ISDIR(fsp->base_fsp->fsp_name->st.st_ex_mode))
3288         {
3289                 /* sorry, but directories don't habe a resource fork */
3290                 rc = -1;
3291                 goto exit;
3292         }
3293
3294         rc = adouble_path(talloc_tos(), smb_fname, &smb_fname_base);
3295         if (rc != 0) {
3296                 goto exit;
3297         }
3298
3299         /* Sanitize flags */
3300         if (flags & O_WRONLY) {
3301                 /* We always need read access for the metadata header too */
3302                 flags &= ~O_WRONLY;
3303                 flags |= O_RDWR;
3304         }
3305
3306         hostfd = SMB_VFS_NEXT_OPEN(handle, smb_fname_base, fsp,
3307                                    flags, mode);
3308         if (hostfd == -1) {
3309                 rc = -1;
3310                 goto exit;
3311         }
3312
3313         if (flags & (O_CREAT | O_TRUNC)) {
3314                 ad = ad_init(fsp, handle, ADOUBLE_RSRC);
3315                 if (ad == NULL) {
3316                         rc = -1;
3317                         goto exit;
3318                 }
3319
3320                 fsp->fh->fd = hostfd;
3321
3322                 rc = ad_fset(ad, fsp);
3323                 fsp->fh->fd = -1;
3324                 if (rc != 0) {
3325                         rc = -1;
3326                         goto exit;
3327                 }
3328                 TALLOC_FREE(ad);
3329         }
3330
3331 exit:
3332
3333         TALLOC_FREE(smb_fname_base);
3334
3335         DEBUG(10, ("fruit_open resource fork: rc=%d, fd=%d\n", rc, hostfd));
3336         if (rc != 0) {
3337                 int saved_errno = errno;
3338                 if (hostfd >= 0) {
3339                         /*
3340                          * BUGBUGBUG -- we would need to call
3341                          * fd_close_posix here, but we don't have a
3342                          * full fsp yet
3343                          */
3344                         fsp->fh->fd = hostfd;
3345                         SMB_VFS_CLOSE(fsp);
3346                 }
3347                 hostfd = -1;
3348                 errno = saved_errno;
3349         }
3350         return hostfd;
3351 }
3352
3353 static int fruit_open_rsrc_xattr(vfs_handle_struct *handle,
3354                                  struct smb_filename *smb_fname,
3355                                  files_struct *fsp,
3356                                  int flags,
3357                                  mode_t mode)
3358 {
3359 #ifdef HAVE_ATTROPEN
3360         int fd = -1;
3361
3362         fd = attropen(smb_fname->base_name,
3363                       AFPRESOURCE_EA_NETATALK,
3364                       flags,
3365                       mode);
3366         if (fd == -1) {
3367                 return -1;
3368         }
3369
3370         return fd;
3371
3372 #else
3373         errno = ENOSYS;
3374         return -1;
3375 #endif
3376 }
3377
3378 static int fruit_open_rsrc(vfs_handle_struct *handle,
3379                            struct smb_filename *smb_fname,
3380                            files_struct *fsp, int flags, mode_t mode)
3381 {
3382         int fd;
3383         struct fruit_config_data *config = NULL;
3384         struct fio *fio = NULL;
3385
3386         DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
3387
3388         SMB_VFS_HANDLE_GET_DATA(handle, config,
3389                                 struct fruit_config_data, return -1);
3390
3391         if (((flags & O_ACCMODE) == O_RDONLY)
3392             && (flags & O_CREAT)
3393             && !VALID_STAT(fsp->fsp_name->st))
3394         {
3395                 /*
3396                  * This means the stream doesn't exist. macOS SMB server fails
3397                  * this with NT_STATUS_OBJECT_NAME_NOT_FOUND, so must we. Cf bug
3398                  * 12565 and the test for this combination in
3399                  * test_rfork_create().
3400                  */
3401                 errno = ENOENT;
3402                 return -1;
3403         }
3404
3405         switch (config->rsrc) {
3406         case FRUIT_RSRC_STREAM:
3407                 fd = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
3408                 break;
3409
3410         case FRUIT_RSRC_ADFILE:
3411                 fd = fruit_open_rsrc_adouble(handle, smb_fname,
3412                                              fsp, flags, mode);
3413                 break;
3414
3415         case FRUIT_RSRC_XATTR:
3416                 fd = fruit_open_rsrc_xattr(handle, smb_fname,
3417                                            fsp, flags, mode);
3418                 break;
3419
3420         default:
3421                 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
3422                 return -1;
3423         }
3424
3425         DBG_DEBUG("Path [%s] fd [%d]\n", smb_fname_str_dbg(smb_fname), fd);
3426
3427         if (fd == -1) {
3428                 return -1;
3429         }
3430
3431         fio = VFS_ADD_FSP_EXTENSION(handle, fsp, struct fio, NULL);
3432         fio->type = ADOUBLE_RSRC;
3433         fio->config = config;
3434
3435         return fd;
3436 }
3437
3438 static int fruit_open(vfs_handle_struct *handle,
3439                       struct smb_filename *smb_fname,
3440                       files_struct *fsp, int flags, mode_t mode)
3441 {
3442         int fd;
3443
3444         DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
3445
3446         if (!is_ntfs_stream_smb_fname(smb_fname)) {
3447                 return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
3448         }
3449
3450         if (is_afpinfo_stream(smb_fname)) {
3451                 fd = fruit_open_meta(handle, smb_fname, fsp, flags, mode);
3452         } else if (is_afpresource_stream(smb_fname)) {
3453                 fd = fruit_open_rsrc(handle, smb_fname, fsp, flags, mode);
3454         } else {
3455                 fd = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
3456         }
3457
3458         DBG_DEBUG("Path [%s] fd [%d]\n", smb_fname_str_dbg(smb_fname), fd);
3459
3460         return fd;
3461 }
3462
3463 static int fruit_rename(struct vfs_handle_struct *handle,
3464                         const struct smb_filename *smb_fname_src,
3465                         const struct smb_filename *smb_fname_dst)
3466 {
3467         int rc = -1;
3468         struct fruit_config_data *config = NULL;
3469         struct smb_filename *src_adp_smb_fname = NULL;
3470         struct smb_filename *dst_adp_smb_fname = NULL;
3471
3472         SMB_VFS_HANDLE_GET_DATA(handle, config,
3473                                 struct fruit_config_data, return -1);
3474
3475         if (!VALID_STAT(smb_fname_src->st)) {
3476                 DBG_ERR("Need valid stat for [%s]\n",
3477                         smb_fname_str_dbg(smb_fname_src));
3478                 return -1;
3479         }
3480
3481         rc = SMB_VFS_NEXT_RENAME(handle, smb_fname_src, smb_fname_dst);
3482         if (rc != 0) {
3483                 return -1;
3484         }
3485
3486         if ((config->rsrc != FRUIT_RSRC_ADFILE) ||
3487             (!S_ISREG(smb_fname_src->st.st_ex_mode)))
3488         {
3489                 return 0;
3490         }
3491
3492         rc = adouble_path(talloc_tos(), smb_fname_src, &src_adp_smb_fname);
3493         if (rc != 0) {
3494                 goto done;
3495         }
3496
3497         rc = adouble_path(talloc_tos(), smb_fname_dst, &dst_adp_smb_fname);
3498         if (rc != 0) {
3499                 goto done;
3500         }
3501
3502         DBG_DEBUG("%s -> %s\n",
3503                   smb_fname_str_dbg(src_adp_smb_fname),
3504                   smb_fname_str_dbg(dst_adp_smb_fname));
3505
3506         rc = SMB_VFS_NEXT_RENAME(handle, src_adp_smb_fname, dst_adp_smb_fname);
3507         if (errno == ENOENT) {
3508                 rc = 0;
3509         }
3510
3511 done:
3512         TALLOC_FREE(src_adp_smb_fname);
3513         TALLOC_FREE(dst_adp_smb_fname);
3514         return rc;
3515 }
3516
3517 static int fruit_unlink_meta_stream(vfs_handle_struct *handle,
3518                                     const struct smb_filename *smb_fname)
3519 {
3520         return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
3521 }
3522
3523 static int fruit_unlink_meta_netatalk(vfs_handle_struct *handle,
3524                                       const struct smb_filename *smb_fname)
3525 {
3526         return SMB_VFS_REMOVEXATTR(handle->conn,
3527                                    smb_fname,
3528                                    AFPINFO_EA_NETATALK);
3529 }
3530
3531 static int fruit_unlink_meta(vfs_handle_struct *handle,
3532                              const struct smb_filename *smb_fname)
3533 {
3534         struct fruit_config_data *config = NULL;
3535         int rc;
3536
3537         SMB_VFS_HANDLE_GET_DATA(handle, config,
3538                                 struct fruit_config_data, return -1);
3539
3540         switch (config->meta) {
3541         case FRUIT_META_STREAM:
3542                 rc = fruit_unlink_meta_stream(handle, smb_fname);
3543                 break;
3544
3545         case FRUIT_META_NETATALK:
3546                 rc = fruit_unlink_meta_netatalk(handle, smb_fname);
3547                 break;
3548
3549         default:
3550                 DBG_ERR("Unsupported meta config [%d]\n", config->meta);
3551                 return -1;
3552         }
3553
3554         return rc;
3555 }
3556
3557 static int fruit_unlink_rsrc_stream(vfs_handle_struct *handle,
3558                                     const struct smb_filename *smb_fname,
3559                                     bool force_unlink)
3560 {
3561         int ret;
3562
3563         if (!force_unlink) {
3564                 struct smb_filename *smb_fname_cp = NULL;
3565                 off_t size;
3566
3567                 smb_fname_cp = cp_smb_filename(talloc_tos(), smb_fname);
3568                 if (smb_fname_cp == NULL) {
3569                         return -1;
3570                 }
3571
3572                 /*
3573                  * 0 byte resource fork streams are not listed by
3574                  * vfs_streaminfo, as a result stream cleanup/deletion of file
3575                  * deletion doesn't remove the resourcefork stream.
3576                  */
3577
3578                 ret = SMB_VFS_NEXT_STAT(handle, smb_fname_cp);
3579                 if (ret != 0) {
3580                         TALLOC_FREE(smb_fname_cp);
3581                         DBG_ERR("stat [%s] failed [%s]\n",
3582                                 smb_fname_str_dbg(smb_fname_cp), strerror(errno));
3583                         return -1;
3584                 }
3585
3586                 size = smb_fname_cp->st.st_ex_size;
3587                 TALLOC_FREE(smb_fname_cp);
3588
3589                 if (size > 0) {
3590                         /* OS X ignores resource fork stream delete requests */
3591                         return 0;
3592                 }
3593         }
3594
3595         ret = SMB_VFS_NEXT_UNLINK(handle, smb_fname);
3596         if ((ret != 0) && (errno == ENOENT) && force_unlink) {
3597                 ret = 0;
3598         }
3599
3600         return ret;
3601 }
3602
3603 static int fruit_unlink_rsrc_adouble(vfs_handle_struct *handle,
3604                                      const struct smb_filename *smb_fname,
3605                                      bool force_unlink)
3606 {
3607         int rc;
3608         struct adouble *ad = NULL;
3609         struct smb_filename *adp_smb_fname = NULL;
3610
3611         if (!force_unlink) {
3612                 ad = ad_get(talloc_tos(), handle, smb_fname,
3613                             ADOUBLE_RSRC);
3614                 if (ad == NULL) {
3615                         errno = ENOENT;
3616                         return -1;
3617                 }
3618
3619
3620                 /*
3621                  * 0 byte resource fork streams are not listed by
3622                  * vfs_streaminfo, as a result stream cleanup/deletion of file
3623                  * deletion doesn't remove the resourcefork stream.
3624                  */
3625
3626                 if (ad_getentrylen(ad, ADEID_RFORK) > 0) {
3627                         /* OS X ignores resource fork stream delete requests */
3628                         TALLOC_FREE(ad);
3629                         return 0;
3630                 }
3631
3632                 TALLOC_FREE(ad);
3633         }
3634
3635         rc = adouble_path(talloc_tos(), smb_fname, &adp_smb_fname);
3636         if (rc != 0) {
3637                 return -1;
3638         }
3639
3640         rc = SMB_VFS_NEXT_UNLINK(handle, adp_smb_fname);
3641         TALLOC_FREE(adp_smb_fname);
3642         if ((rc != 0) && (errno == ENOENT) && force_unlink) {
3643                 rc = 0;
3644         }
3645
3646         return rc;
3647 }
3648
3649 static int fruit_unlink_rsrc_xattr(vfs_handle_struct *handle,
3650                                    const struct smb_filename *smb_fname,
3651                                    bool force_unlink)
3652 {
3653         /*
3654          * OS X ignores resource fork stream delete requests, so nothing to do
3655          * here. Removing the file will remove the xattr anyway, so we don't
3656          * have to take care of removing 0 byte resource forks that could be
3657          * left behind.
3658          */
3659         return 0;
3660 }
3661
3662 static int fruit_unlink_rsrc(vfs_handle_struct *handle,
3663                              const struct smb_filename *smb_fname,
3664                              bool force_unlink)
3665 {
3666         struct fruit_config_data *config = NULL;
3667         int rc;
3668
3669         SMB_VFS_HANDLE_GET_DATA(handle, config,
3670                                 struct fruit_config_data, return -1);
3671
3672         switch (config->rsrc) {
3673         case FRUIT_RSRC_STREAM:
3674                 rc = fruit_unlink_rsrc_stream(handle, smb_fname, force_unlink);
3675                 break;
3676
3677         case FRUIT_RSRC_ADFILE:
3678                 rc = fruit_unlink_rsrc_adouble(handle, smb_fname, force_unlink);
3679                 break;
3680
3681         case FRUIT_RSRC_XATTR:
3682                 rc = fruit_unlink_rsrc_xattr(handle, smb_fname, force_unlink);
3683                 break;
3684
3685         default:
3686                 DBG_ERR("Unsupported rsrc config [%d]\n", config->rsrc);
3687                 return -1;
3688         }
3689
3690         return rc;
3691 }
3692
3693 static int fruit_unlink(vfs_handle_struct *handle,
3694                         const struct smb_filename *smb_fname)
3695 {
3696         int rc;
3697         struct fruit_config_data *config = NULL;
3698         struct smb_filename *rsrc_smb_fname = NULL;
3699
3700         SMB_VFS_HANDLE_GET_DATA(handle, config,
3701                                 struct fruit_config_data, return -1);
3702
3703         if (is_afpinfo_stream(smb_fname)) {
3704                 return fruit_unlink_meta(handle, smb_fname);
3705         } else if (is_afpresource_stream(smb_fname)) {
3706                 return fruit_unlink_rsrc(handle, smb_fname, false);
3707         } if (is_ntfs_stream_smb_fname(smb_fname)) {
3708                 return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
3709         }
3710
3711         /*
3712          * A request to delete the base file. Because 0 byte resource
3713          * fork streams are not listed by fruit_streaminfo,
3714          * delete_all_streams() can't remove 0 byte resource fork
3715          * streams, so we have to cleanup this here.
3716          */
3717         rsrc_smb_fname = synthetic_smb_fname(talloc_tos(),
3718                                              smb_fname->base_name,
3719                                              AFPRESOURCE_STREAM_NAME,
3720                                              NULL,
3721                                              smb_fname->flags);
3722         if (rsrc_smb_fname == NULL) {
3723                 return -1;
3724         }
3725
3726         rc = fruit_unlink_rsrc(handle, rsrc_smb_fname, true);
3727         if ((rc != 0) && (errno != ENOENT)) {
3728                 DBG_ERR("Forced unlink of [%s] failed [%s]\n",
3729                         smb_fname_str_dbg(rsrc_smb_fname), strerror(errno));
3730                 TALLOC_FREE(rsrc_smb_fname);
3731                 return -1;
3732         }
3733         TALLOC_FREE(rsrc_smb_fname);
3734
3735         return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
3736 }
3737
3738 static int fruit_chmod(vfs_handle_struct *handle,
3739                        const struct smb_filename *smb_fname,
3740                        mode_t mode)
3741 {
3742         int rc = -1;
3743         struct fruit_config_data *config = NULL;
3744         struct smb_filename *smb_fname_adp = NULL;
3745
3746         rc = SMB_VFS_NEXT_CHMOD(handle, smb_fname, mode);
3747         if (rc != 0) {
3748                 return rc;
3749         }
3750
3751         SMB_VFS_HANDLE_GET_DATA(handle, config,
3752                                 struct fruit_config_data, return -1);
3753
3754         if (config->rsrc != FRUIT_RSRC_ADFILE) {
3755                 return 0;
3756         }
3757
3758         if (!VALID_STAT(smb_fname->st)) {
3759                 return 0;
3760         }
3761
3762         if (!S_ISREG(smb_fname->st.st_ex_mode)) {
3763                 return 0;
3764         }
3765
3766         rc = adouble_path(talloc_tos(), smb_fname, &smb_fname_adp);
3767         if (rc != 0) {
3768                 return -1;
3769         }
3770
3771         DEBUG(10, ("fruit_chmod: %s\n", smb_fname_adp->base_name));
3772
3773         rc = SMB_VFS_NEXT_CHMOD(handle, smb_fname_adp, mode);
3774         if (errno == ENOENT) {
3775                 rc = 0;
3776         }
3777
3778         TALLOC_FREE(smb_fname_adp);
3779         return rc;
3780 }
3781
3782 static int fruit_chown(vfs_handle_struct *handle,
3783                        const struct smb_filename *smb_fname,
3784                        uid_t uid,
3785                        gid_t gid)
3786 {
3787         int rc = -1;
3788         struct fruit_config_data *config = NULL;
3789         struct smb_filename *adp_smb_fname = NULL;
3790
3791         rc = SMB_VFS_NEXT_CHOWN(handle, smb_fname, uid, gid);
3792         if (rc != 0) {
3793                 return rc;
3794         }
3795
3796         SMB_VFS_HANDLE_GET_DATA(handle, config,
3797                                 struct fruit_config_data, return -1);
3798
3799         if (config->rsrc != FRUIT_RSRC_ADFILE) {
3800                 return 0;
3801         }
3802
3803         if (!VALID_STAT(smb_fname->st)) {
3804                 return 0;
3805         }
3806
3807         if (!S_ISREG(smb_fname->st.st_ex_mode)) {
3808                 return 0;
3809         }
3810
3811         rc = adouble_path(talloc_tos(), smb_fname, &adp_smb_fname);
3812         if (rc != 0) {
3813                 goto done;
3814         }
3815
3816         DEBUG(10, ("fruit_chown: %s\n", adp_smb_fname->base_name));
3817
3818         rc = SMB_VFS_NEXT_CHOWN(handle, adp_smb_fname, uid, gid);
3819         if (errno == ENOENT) {
3820                 rc = 0;
3821         }
3822
3823  done:
3824         TALLOC_FREE(adp_smb_fname);
3825         return rc;
3826 }
3827
3828 static int fruit_rmdir(struct vfs_handle_struct *handle,
3829                         const struct smb_filename *smb_fname)
3830 {
3831         DIR *dh = NULL;
3832         struct dirent *de;
3833         struct fruit_config_data *config;
3834
3835         SMB_VFS_HANDLE_GET_DATA(handle, config,
3836                                 struct fruit_config_data, return -1);
3837
3838         if (config->rsrc != FRUIT_RSRC_ADFILE) {
3839                 goto exit_rmdir;
3840         }
3841
3842         /*
3843          * Due to there is no way to change bDeleteVetoFiles variable
3844          * from this module, need to clean up ourselves
3845          */
3846
3847         dh = SMB_VFS_OPENDIR(handle->conn, smb_fname, NULL, 0);
3848         if (dh == NULL) {
3849                 goto exit_rmdir;
3850         }
3851
3852         while ((de = SMB_VFS_READDIR(handle->conn, dh, NULL)) != NULL) {
3853                 int match;
3854                 struct adouble *ad = NULL;
3855                 char *p = NULL;
3856                 struct smb_filename *ad_smb_fname = NULL;
3857                 int ret;
3858
3859                 match = strncmp(de->d_name,
3860                                 ADOUBLE_NAME_PREFIX,
3861                                 strlen(ADOUBLE_NAME_PREFIX));
3862                 if (match != 0) {
3863                         continue;
3864                 }
3865
3866                 p = talloc_asprintf(talloc_tos(), "%s/%s",
3867                                     smb_fname->base_name, de->d_name);
3868                 if (p == NULL) {
3869                         DBG_ERR("talloc_asprintf failed\n");
3870                         return -1;
3871                 }
3872
3873                 ad_smb_fname = synthetic_smb_fname(talloc_tos(), p,
3874                                                     NULL, NULL,
3875                                                     smb_fname->flags);
3876                 TALLOC_FREE(p);
3877                 if (ad_smb_fname == NULL) {
3878                         DBG_ERR("synthetic_smb_fname failed\n");
3879                         return -1;
3880                 }
3881
3882                 /*
3883                  * Check whether it's a valid AppleDouble file, if
3884                  * yes, delete it, ignore it otherwise.
3885                  */
3886                 ad = ad_get(talloc_tos(), handle, ad_smb_fname, ADOUBLE_RSRC);
3887                 if (ad == NULL) {
3888                         TALLOC_FREE(ad_smb_fname);
3889                         TALLOC_FREE(p);
3890                         continue;
3891                 }
3892                 TALLOC_FREE(ad);
3893
3894                 ret = SMB_VFS_NEXT_UNLINK(handle, ad_smb_fname);
3895                 if (ret != 0) {
3896                         DBG_ERR("Deleting [%s] failed\n",
3897                                 smb_fname_str_dbg(ad_smb_fname));
3898                 }
3899                 TALLOC_FREE(ad_smb_fname);
3900         }
3901
3902 exit_rmdir:
3903         if (dh) {
3904                 SMB_VFS_CLOSEDIR(handle->conn, dh);
3905         }
3906         return SMB_VFS_NEXT_RMDIR(handle, smb_fname);
3907 }
3908
3909 static ssize_t fruit_pread_meta_stream(vfs_handle_struct *handle,
3910                                        files_struct *fsp, void *data,
3911                                        size_t n, off_t offset)
3912 {
3913         ssize_t nread;
3914         int ret;
3915
3916         nread = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
3917
3918         if (nread == n) {
3919                 return nread;
3920         }
3921
3922         DBG_ERR("Removing [%s] after short read [%zd]\n",
3923                 fsp_str_dbg(fsp), nread);
3924
3925         ret = SMB_VFS_NEXT_UNLINK(handle, fsp->fsp_name);
3926         if (ret != 0) {
3927                 DBG_ERR("Removing [%s] failed\n", fsp_str_dbg(fsp));
3928                 return -1;
3929         }
3930
3931         errno = EINVAL;
3932         return -1;
3933 }
3934
3935 static ssize_t fruit_pread_meta_adouble(vfs_handle_struct *handle,
3936                                         files_struct *fsp, void *data,
3937                                         size_t n, off_t offset)
3938 {
3939         AfpInfo *ai = NULL;
3940         struct adouble *ad = NULL;
3941         char afpinfo_buf[AFP_INFO_SIZE];
3942         char *p = NULL;
3943         ssize_t nread;
3944
3945         ai = afpinfo_new(talloc_tos());
3946         if (ai == NULL) {
3947                 return -1;
3948         }
3949
3950         ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_META);
3951         if (ad == NULL) {
3952                 nread = -1;
3953                 goto fail;
3954         }
3955
3956         p = ad_get_entry(ad, ADEID_FINDERI);
3957         if (p == NULL) {
3958                 DBG_ERR("No ADEID_FINDERI for [%s]\n", fsp_str_dbg(fsp));
3959                 nread = -1;
3960                 goto fail;
3961         }
3962
3963         memcpy(&ai->afpi_FinderInfo[0], p, ADEDLEN_FINDERI);
3964
3965         nread = afpinfo_pack(ai, afpinfo_buf);
3966         if (nread != AFP_INFO_SIZE) {
3967                 nread = -1;
3968                 goto fail;
3969         }
3970
3971         memcpy(data, afpinfo_buf, n);
3972         nread = n;
3973
3974 fail:
3975         TALLOC_FREE(ai);
3976         return nread;
3977 }
3978
3979 static ssize_t fruit_pread_meta(vfs_handle_struct *handle,
3980                                 files_struct *fsp, void *data,
3981                                 size_t n, off_t offset)
3982 {
3983         struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
3984         ssize_t nread;
3985         ssize_t to_return;
3986
3987         /*
3988          * OS X has a off-by-1 error in the offset calculation, so we're
3989          * bug compatible here. It won't hurt, as any relevant real
3990          * world read requests from the AFP_AfpInfo stream will be
3991          * offset=0 n=60. offset is ignored anyway, see below.
3992          */
3993         if ((offset < 0) || (offset >= AFP_INFO_SIZE + 1)) {
3994                 return 0;
3995         }
3996
3997         /* Yes, macOS always reads from offset 0 */
3998         offset = 0;
3999         to_return = MIN(n, AFP_INFO_SIZE);
4000
4001         switch (fio->config->meta) {
4002         case FRUIT_META_STREAM:
4003                 nread = fruit_pread_meta_stream(handle, fsp, data,
4004                                                 to_return, offset);
4005                 break;
4006
4007         case FRUIT_META_NETATALK:
4008                 nread = fruit_pread_meta_adouble(handle, fsp, data,
4009                                                  to_return, offset);
4010                 break;
4011
4012         default:
4013                 DBG_ERR("Unexpected meta config [%d]\n", fio->config->meta);
4014                 return -1;
4015         }
4016
4017         return nread;
4018 }
4019
4020 static ssize_t fruit_pread_rsrc_stream(vfs_handle_struct *handle,
4021                                        files_struct *fsp, void *data,
4022                                        size_t n, off_t offset)
4023 {
4024         return SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
4025 }
4026
4027 static ssize_t fruit_pread_rsrc_xattr(vfs_handle_struct *handle,
4028                                       files_struct *fsp, void *data,
4029                                       size_t n, off_t offset)
4030 {
4031         return SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
4032 }
4033
4034 static ssize_t fruit_pread_rsrc_adouble(vfs_handle_struct *handle,
4035                                         files_struct *fsp, void *data,
4036                                         size_t n, off_t offset)
4037 {
4038         struct adouble *ad = NULL;
4039         ssize_t nread;
4040
4041         ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_RSRC);
4042         if (ad == NULL) {
4043                 return -1;
4044         }
4045
4046         nread = SMB_VFS_NEXT_PREAD(handle, fsp, data, n,
4047                                    offset + ad_getentryoff(ad, ADEID_RFORK));
4048
4049         TALLOC_FREE(ad);
4050         return nread;
4051 }
4052
4053 static ssize_t fruit_pread_rsrc(vfs_handle_struct *handle,
4054                                 files_struct *fsp, void *data,
4055                                 size_t n, off_t offset)
4056 {
4057         struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4058         ssize_t nread;
4059
4060         switch (fio->config->rsrc) {
4061         case FRUIT_RSRC_STREAM:
4062                 nread = fruit_pread_rsrc_stream(handle, fsp, data, n, offset);
4063                 break;
4064
4065         case FRUIT_RSRC_ADFILE:
4066                 nread = fruit_pread_rsrc_adouble(handle, fsp, data, n, offset);
4067                 break;
4068
4069         case FRUIT_RSRC_XATTR:
4070                 nread = fruit_pread_rsrc_xattr(handle, fsp, data, n, offset);
4071                 break;
4072
4073         default:
4074                 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
4075                 return -1;
4076         }
4077
4078         return nread;
4079 }
4080
4081 static ssize_t fruit_pread(vfs_handle_struct *handle,
4082                            files_struct *fsp, void *data,
4083                            size_t n, off_t offset)
4084 {
4085         struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4086         ssize_t nread;
4087
4088         DBG_DEBUG("Path [%s] offset=%"PRIdMAX", size=%zd\n",
4089                   fsp_str_dbg(fsp), (intmax_t)offset, n);
4090
4091         if (fio == NULL) {
4092                 return SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
4093         }
4094
4095         if (fio->type == ADOUBLE_META) {
4096                 nread = fruit_pread_meta(handle, fsp, data, n, offset);
4097         } else {
4098                 nread = fruit_pread_rsrc(handle, fsp, data, n, offset);
4099         }
4100
4101         DBG_DEBUG("Path [%s] nread [%zd]\n", fsp_str_dbg(fsp), nread);
4102         return nread;
4103 }
4104
4105 static bool fruit_must_handle_aio_stream(struct fio *fio)
4106 {
4107         if (fio == NULL) {
4108                 return false;
4109         };
4110
4111         if ((fio->type == ADOUBLE_META) &&
4112             (fio->config->meta == FRUIT_META_NETATALK))
4113         {
4114                 return true;
4115         }
4116
4117         if ((fio->type == ADOUBLE_RSRC) &&
4118             (fio->config->rsrc == FRUIT_RSRC_ADFILE))
4119         {
4120                 return true;
4121         }
4122
4123         return false;
4124 }
4125
4126 struct fruit_pread_state {
4127         ssize_t nread;
4128         struct vfs_aio_state vfs_aio_state;
4129 };
4130
4131 static void fruit_pread_done(struct tevent_req *subreq);
4132
4133 static struct tevent_req *fruit_pread_send(
4134         struct vfs_handle_struct *handle,
4135         TALLOC_CTX *mem_ctx,
4136         struct tevent_context *ev,
4137         struct files_struct *fsp,
4138         void *data,
4139         size_t n, off_t offset)
4140 {
4141         struct tevent_req *req = NULL;
4142         struct tevent_req *subreq = NULL;
4143         struct fruit_pread_state *state = NULL;
4144         struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4145
4146         req = tevent_req_create(mem_ctx, &state,
4147                                 struct fruit_pread_state);
4148         if (req == NULL) {
4149                 return NULL;
4150         }
4151
4152         if (fruit_must_handle_aio_stream(fio)) {
4153                 state->nread = SMB_VFS_PREAD(fsp, data, n, offset);
4154                 if (state->nread != n) {
4155                         if (state->nread != -1) {
4156                                 errno = EIO;
4157                         }
4158                         tevent_req_error(req, errno);
4159                         return tevent_req_post(req, ev);
4160                 }
4161                 tevent_req_done(req);
4162                 return tevent_req_post(req, ev);
4163         }
4164
4165         subreq = SMB_VFS_NEXT_PREAD_SEND(state, ev, handle, fsp,
4166                                          data, n, offset);
4167         if (tevent_req_nomem(req, subreq)) {
4168                 return tevent_req_post(req, ev);
4169         }
4170         tevent_req_set_callback(subreq, fruit_pread_done, req);
4171         return req;
4172 }
4173
4174 static void fruit_pread_done(struct tevent_req *subreq)
4175 {
4176         struct tevent_req *req = tevent_req_callback_data(
4177                 subreq, struct tevent_req);
4178         struct fruit_pread_state *state = tevent_req_data(
4179                 req, struct fruit_pread_state);
4180
4181         state->nread = SMB_VFS_PREAD_RECV(subreq, &state->vfs_aio_state);
4182         TALLOC_FREE(subreq);
4183
4184         if (tevent_req_error(req, state->vfs_aio_state.error)) {
4185                 return;
4186         }
4187         tevent_req_done(req);
4188 }
4189
4190 static ssize_t fruit_pread_recv(struct tevent_req *req,
4191                                         struct vfs_aio_state *vfs_aio_state)
4192 {
4193         struct fruit_pread_state *state = tevent_req_data(
4194                 req, struct fruit_pread_state);
4195
4196         if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
4197                 return -1;
4198         }
4199
4200         *vfs_aio_state = state->vfs_aio_state;
4201         return state->nread;
4202 }
4203
4204 static ssize_t fruit_pwrite_meta_stream(vfs_handle_struct *handle,
4205                                         files_struct *fsp, const void *data,
4206                                         size_t n, off_t offset)
4207 {
4208         AfpInfo *ai = NULL;
4209         size_t nwritten;
4210         bool ok;
4211
4212         ai = afpinfo_unpack(talloc_tos(), data);
4213         if (ai == NULL) {
4214                 return -1;
4215         }
4216
4217         nwritten = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
4218         if (nwritten != n) {
4219                 return -1;
4220         }
4221
4222         if (!ai_empty_finderinfo(ai)) {
4223                 return n;
4224         }
4225
4226         ok = set_delete_on_close(
4227                         fsp,
4228                         true,
4229                         handle->conn->session_info->security_token,
4230                         handle->conn->session_info->unix_token);
4231         if (!ok) {
4232                 DBG_ERR("set_delete_on_close on [%s] failed\n",
4233                         fsp_str_dbg(fsp));
4234                 return -1;
4235         }
4236
4237         return n;
4238 }
4239
4240 static ssize_t fruit_pwrite_meta_netatalk(vfs_handle_struct *handle,
4241                                           files_struct *fsp, const void *data,
4242                                           size_t n, off_t offset)
4243 {
4244         struct adouble *ad = NULL;
4245         AfpInfo *ai = NULL;
4246         char *p = NULL;
4247         int ret;
4248         bool ok;
4249
4250         ai = afpinfo_unpack(talloc_tos(), data);
4251         if (ai == NULL) {
4252                 return -1;
4253         }
4254
4255         ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_META);
4256         if (ad == NULL) {
4257                 ad = ad_init(talloc_tos(), handle, ADOUBLE_META);
4258                 if (ad == NULL) {
4259                         return -1;
4260                 }
4261         }
4262         p = ad_get_entry(ad, ADEID_FINDERI);
4263         if (p == NULL) {
4264                 DBG_ERR("No ADEID_FINDERI for [%s]\n", fsp_str_dbg(fsp));
4265                 TALLOC_FREE(ad);
4266                 return -1;
4267         }
4268
4269         memcpy(p, &ai->afpi_FinderInfo[0], ADEDLEN_FINDERI);
4270
4271         ret = ad_fset(ad, fsp);
4272         if (ret != 0) {
4273                 DBG_ERR("ad_pwrite [%s] failed\n", fsp_str_dbg(fsp));
4274                 TALLOC_FREE(ad);
4275                 return -1;
4276         }
4277
4278         TALLOC_FREE(ad);
4279
4280         if (!ai_empty_finderinfo(ai)) {
4281                 return n;
4282         }
4283
4284         ok = set_delete_on_close(
4285                 fsp,
4286                 true,
4287                 handle->conn->session_info->security_token,
4288                 handle->conn->session_info->unix_token);
4289         if (!ok) {
4290                 DBG_ERR("set_delete_on_close on [%s] failed\n",
4291                         fsp_str_dbg(fsp));
4292                 return -1;
4293         }
4294
4295         return n;
4296 }
4297
4298 static ssize_t fruit_pwrite_meta(vfs_handle_struct *handle,
4299                                  files_struct *fsp, const void *data,
4300                                  size_t n, off_t offset)
4301 {
4302         struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4303         ssize_t nwritten;
4304
4305         /*
4306          * Writing an all 0 blob to the metadata stream
4307          * results in the stream being removed on a macOS
4308          * server. This ensures we behave the same and it
4309          * verified by the "delete AFP_AfpInfo by writing all
4310          * 0" test.
4311          */
4312         if (n != AFP_INFO_SIZE || offset != 0) {
4313                 DBG_ERR("unexpected offset=%jd or size=%jd\n",
4314                         (intmax_t)offset, (intmax_t)n);
4315                 return -1;
4316         }
4317
4318         switch (fio->config->meta) {
4319         case FRUIT_META_STREAM:
4320                 nwritten = fruit_pwrite_meta_stream(handle, fsp, data,
4321                                                     n, offset);
4322                 break;
4323
4324         case FRUIT_META_NETATALK:
4325                 nwritten = fruit_pwrite_meta_netatalk(handle, fsp, data,
4326                                                       n, offset);
4327                 break;
4328
4329         default:
4330                 DBG_ERR("Unexpected meta config [%d]\n", fio->config->meta);
4331                 return -1;
4332         }
4333
4334         return nwritten;
4335 }
4336
4337 static ssize_t fruit_pwrite_rsrc_stream(vfs_handle_struct *handle,
4338                                         files_struct *fsp, const void *data,
4339                                         size_t n, off_t offset)
4340 {
4341         return SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
4342 }
4343
4344 static ssize_t fruit_pwrite_rsrc_xattr(vfs_handle_struct *handle,
4345                                        files_struct *fsp, const void *data,
4346                                        size_t n, off_t offset)
4347 {
4348         return SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
4349 }
4350
4351 static ssize_t fruit_pwrite_rsrc_adouble(vfs_handle_struct *handle,
4352                                          files_struct *fsp, const void *data,
4353                                          size_t n, off_t offset)
4354 {
4355         struct adouble *ad = NULL;
4356         ssize_t nwritten;
4357         int ret;
4358
4359         ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_RSRC);
4360         if (ad == NULL) {
4361                 DBG_ERR("ad_get [%s] failed\n", fsp_str_dbg(fsp));
4362                 return -1;
4363         }
4364
4365         nwritten = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n,
4366                                        offset + ad_getentryoff(ad, ADEID_RFORK));
4367         if (nwritten != n) {
4368                 DBG_ERR("Short write on [%s] [%zd/%zd]\n",
4369                         fsp_str_dbg(fsp), nwritten, n);
4370                 TALLOC_FREE(ad);
4371                 return -1;
4372         }
4373
4374         if ((n + offset) > ad_getentrylen(ad, ADEID_RFORK)) {
4375                 ad_setentrylen(ad, ADEID_RFORK, n + offset);
4376                 ret = ad_fset(ad, fsp);
4377                 if (ret != 0) {
4378                         DBG_ERR("ad_pwrite [%s] failed\n", fsp_str_dbg(fsp));
4379                         TALLOC_FREE(ad);
4380                         return -1;
4381                 }
4382         }
4383
4384         TALLOC_FREE(ad);
4385         return n;
4386 }
4387
4388 static ssize_t fruit_pwrite_rsrc(vfs_handle_struct *handle,
4389                                  files_struct *fsp, const void *data,
4390                                  size_t n, off_t offset)
4391 {
4392         struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4393         ssize_t nwritten;
4394
4395         switch (fio->config->rsrc) {
4396         case FRUIT_RSRC_STREAM:
4397                 nwritten = fruit_pwrite_rsrc_stream(handle, fsp, data, n, offset);
4398                 break;
4399
4400         case FRUIT_RSRC_ADFILE:
4401                 nwritten = fruit_pwrite_rsrc_adouble(handle, fsp, data, n, offset);
4402                 break;
4403
4404         case FRUIT_RSRC_XATTR:
4405                 nwritten = fruit_pwrite_rsrc_xattr(handle, fsp, data, n, offset);
4406                 break;
4407
4408         default:
4409                 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
4410                 return -1;
4411         }
4412
4413         return nwritten;
4414 }
4415
4416 static ssize_t fruit_pwrite(vfs_handle_struct *handle,
4417                             files_struct *fsp, const void *data,
4418                             size_t n, off_t offset)
4419 {
4420         struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4421         ssize_t nwritten;
4422
4423         DBG_DEBUG("Path [%s] offset=%"PRIdMAX", size=%zd\n",
4424                   fsp_str_dbg(fsp), (intmax_t)offset, n);
4425
4426         if (fio == NULL) {
4427                 return SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
4428         }
4429
4430         if (fio->type == ADOUBLE_META) {
4431                 nwritten = fruit_pwrite_meta(handle, fsp, data, n, offset);
4432         } else {
4433                 nwritten = fruit_pwrite_rsrc(handle, fsp, data, n, offset);
4434         }
4435
4436         DBG_DEBUG("Path [%s] nwritten=%zd\n", fsp_str_dbg(fsp), nwritten);
4437         return nwritten;
4438 }
4439
4440 struct fruit_pwrite_state {
4441         ssize_t nwritten;
4442         struct vfs_aio_state vfs_aio_state;
4443 };
4444
4445 static void fruit_pwrite_done(struct tevent_req *subreq);
4446
4447 static struct tevent_req *fruit_pwrite_send(
4448         struct vfs_handle_struct *handle,
4449         TALLOC_CTX *mem_ctx,
4450         struct tevent_context *ev,
4451         struct files_struct *fsp,
4452         const void *data,
4453         size_t n, off_t offset)
4454 {
4455         struct tevent_req *req = NULL;
4456         struct tevent_req *subreq = NULL;
4457         struct fruit_pwrite_state *state = NULL;
4458         struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4459
4460         req = tevent_req_create(mem_ctx, &state,
4461                                 struct fruit_pwrite_state);
4462         if (req == NULL) {
4463                 return NULL;
4464         }
4465
4466         if (fruit_must_handle_aio_stream(fio)) {
4467                 state->nwritten = SMB_VFS_PWRITE(fsp, data, n, offset);
4468                 if (state->nwritten != n) {
4469                         if (state->nwritten != -1) {
4470                                 errno = EIO;
4471                         }
4472                         tevent_req_error(req, errno);
4473                         return tevent_req_post(req, ev);
4474                 }
4475                 tevent_req_done(req);
4476                 return tevent_req_post(req, ev);
4477         }
4478
4479         subreq = SMB_VFS_NEXT_PWRITE_SEND(state, ev, handle, fsp,
4480                                           data, n, offset);
4481         if (tevent_req_nomem(req, subreq)) {
4482                 return tevent_req_post(req, ev);
4483         }
4484         tevent_req_set_callback(subreq, fruit_pwrite_done, req);
4485         return req;
4486 }
4487
4488 static void fruit_pwrite_done(struct tevent_req *subreq)
4489 {
4490         struct tevent_req *req = tevent_req_callback_data(
4491                 subreq, struct tevent_req);
4492         struct fruit_pwrite_state *state = tevent_req_data(
4493                 req, struct fruit_pwrite_state);
4494
4495         state->nwritten = SMB_VFS_PWRITE_RECV(subreq, &state->vfs_aio_state);
4496         TALLOC_FREE(subreq);
4497
4498         if (tevent_req_error(req, state->vfs_aio_state.error)) {
4499                 return;
4500         }
4501         tevent_req_done(req);
4502 }
4503
4504 static ssize_t fruit_pwrite_recv(struct tevent_req *req,
4505                                          struct vfs_aio_state *vfs_aio_state)
4506 {
4507         struct fruit_pwrite_state *state = tevent_req_data(
4508                 req, struct fruit_pwrite_state);
4509
4510         if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
4511                 return -1;
4512         }
4513
4514         *vfs_aio_state = state->vfs_aio_state;
4515         return state->nwritten;
4516 }
4517
4518 /**
4519  * Helper to stat/lstat the base file of an smb_fname.
4520  */
4521 static int fruit_stat_base(vfs_handle_struct *handle,
4522                            struct smb_filename *smb_fname,
4523                            bool follow_links)
4524 {
4525         char *tmp_stream_name;
4526         int rc;
4527
4528         tmp_stream_name = smb_fname->stream_name;
4529         smb_fname->stream_name = NULL;
4530         if (follow_links) {
4531                 rc = SMB_VFS_NEXT_STAT(handle, smb_fname);
4532         } else {
4533                 rc = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
4534         }
4535         smb_fname->stream_name = tmp_stream_name;
4536         return rc;
4537 }
4538
4539 static int fruit_stat_meta_stream(vfs_handle_struct *handle,
4540                                   struct smb_filename *smb_fname,
4541                                   bool follow_links)
4542 {
4543         int ret;
4544
4545         if (follow_links) {
4546                 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
4547         } else {
4548                 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
4549         }
4550
4551         return ret;
4552 }
4553
4554 static int fruit_stat_meta_netatalk(vfs_handle_struct *handle,
4555                                     struct smb_filename *smb_fname,
4556                                     bool follow_links)
4557 {
4558         struct adouble *ad = NULL;
4559
4560         ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_META);
4561         if (ad == NULL) {
4562                 DBG_INFO("fruit_stat_meta %s: %s\n",
4563                          smb_fname_str_dbg(smb_fname), strerror(errno));
4564                 errno = ENOENT;
4565                 return -1;
4566         }
4567         TALLOC_FREE(ad);
4568
4569         /* Populate the stat struct with info from the base file. */
4570         if (fruit_stat_base(handle, smb_fname, follow_links) == -1) {
4571                 return -1;
4572         }
4573         smb_fname->st.st_ex_size = AFP_INFO_SIZE;
4574         smb_fname->st.st_ex_ino = fruit_inode(&smb_fname->st,
4575                                               smb_fname->stream_name);
4576         return 0;
4577 }
4578
4579 static int fruit_stat_meta(vfs_handle_struct *handle,
4580                            struct smb_filename *smb_fname,
4581                            bool follow_links)
4582 {
4583         struct fruit_config_data *config = NULL;
4584         int ret;
4585
4586         SMB_VFS_HANDLE_GET_DATA(handle, config,
4587                                 struct fruit_config_data, return -1);
4588
4589         switch (config->meta) {
4590         case FRUIT_META_STREAM:
4591                 ret = fruit_stat_meta_stream(handle, smb_fname, follow_links);
4592                 break;
4593
4594         case FRUIT_META_NETATALK:
4595                 ret = fruit_stat_meta_netatalk(handle, smb_fname, follow_links);
4596                 break;
4597
4598         default:
4599                 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
4600                 return -1;
4601         }
4602
4603         return ret;
4604 }
4605
4606 static int fruit_stat_rsrc_netatalk(vfs_handle_struct *handle,
4607                                     struct smb_filename *smb_fname,
4608                                     bool follow_links)
4609 {
4610         struct adouble *ad = NULL;
4611         int ret;
4612
4613         ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_RSRC);
4614         if (ad == NULL) {
4615                 errno = ENOENT;
4616                 return -1;
4617         }
4618
4619         /* Populate the stat struct with info from the base file. */
4620         ret = fruit_stat_base(handle, smb_fname, follow_links);
4621         if (ret != 0) {
4622                 TALLOC_FREE(ad);
4623                 return -1;
4624         }
4625
4626         smb_fname->st.st_ex_size = ad_getentrylen(ad, ADEID_RFORK);
4627         smb_fname->st.st_ex_ino = fruit_inode(&smb_fname->st,
4628                                               smb_fname->stream_name);
4629         TALLOC_FREE(ad);
4630         return 0;
4631 }
4632
4633 static int fruit_stat_rsrc_stream(vfs_handle_struct *handle,
4634                                   struct smb_filename *smb_fname,
4635                                   bool follow_links)
4636 {
4637         int ret;
4638
4639         if (follow_links) {
4640                 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
4641         } else {
4642                 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
4643         }
4644
4645         return ret;
4646 }
4647
4648 static int fruit_stat_rsrc_xattr(vfs_handle_struct *handle,
4649                                  struct smb_filename *smb_fname,
4650                                  bool follow_links)
4651 {
4652 #ifdef HAVE_ATTROPEN
4653         int ret;
4654         int fd = -1;
4655
4656         /* Populate the stat struct with info from the base file. */
4657         ret = fruit_stat_base(handle, smb_fname, follow_links);
4658         if (ret != 0) {
4659                 return -1;
4660         }
4661
4662         fd = attropen(smb_fname->base_name,
4663                       AFPRESOURCE_EA_NETATALK,
4664                       O_RDONLY);
4665         if (fd == -1) {
4666                 return 0;
4667         }
4668
4669         ret = sys_fstat(fd, &smb_fname->st, false);
4670         if (ret != 0) {
4671                 close(fd);
4672                 DBG_ERR("fstat [%s:%s] failed\n", smb_fname->base_name,
4673                         AFPRESOURCE_EA_NETATALK);
4674                 return -1;
4675         }
4676         close(fd);
4677         fd = -1;
4678
4679         smb_fname->st.st_ex_ino = fruit_inode(&smb_fname->st,
4680                                               smb_fname->stream_name);
4681
4682         return ret;
4683
4684 #else
4685         errno = ENOSYS;
4686         return -1;
4687 #endif
4688 }
4689
4690 static int fruit_stat_rsrc(vfs_handle_struct *handle,
4691                            struct smb_filename *smb_fname,
4692                            bool follow_links)
4693 {
4694         struct fruit_config_data *config = NULL;
4695         int ret;
4696
4697         DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
4698
4699         SMB_VFS_HANDLE_GET_DATA(handle, config,
4700                                 struct fruit_config_data, return -1);
4701
4702         switch (config->rsrc) {
4703         case FRUIT_RSRC_STREAM:
4704                 ret = fruit_stat_rsrc_stream(handle, smb_fname, follow_links);
4705                 break;
4706
4707         case FRUIT_RSRC_XATTR:
4708                 ret = fruit_stat_rsrc_xattr(handle, smb_fname, follow_links);
4709                 break;
4710
4711         case FRUIT_RSRC_ADFILE:
4712                 ret = fruit_stat_rsrc_netatalk(handle, smb_fname, follow_links);
4713                 break;
4714
4715         default:
4716                 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
4717                 return -1;
4718         }
4719
4720         return ret;
4721 }
4722
4723 static int fruit_stat(vfs_handle_struct *handle,
4724                       struct smb_filename *smb_fname)
4725 {
4726         int rc = -1;
4727
4728         DEBUG(10, ("fruit_stat called for %s\n",
4729                    smb_fname_str_dbg(smb_fname)));
4730
4731         if (!is_ntfs_stream_smb_fname(smb_fname)
4732             || is_ntfs_default_stream_smb_fname(smb_fname)) {
4733                 rc = SMB_VFS_NEXT_STAT(handle, smb_fname);
4734                 if (rc == 0) {
4735                         update_btime(handle, smb_fname);
4736                 }
4737                 return rc;
4738         }
4739
4740         /*
4741          * Note if lp_posix_paths() is true, we can never
4742          * get here as is_ntfs_stream_smb_fname() is
4743          * always false. So we never need worry about
4744          * not following links here.
4745          */
4746
4747         if (is_afpinfo_stream(smb_fname)) {
4748                 rc = fruit_stat_meta(handle, smb_fname, true);
4749         } else if (is_afpresource_stream(smb_fname)) {
4750                 rc = fruit_stat_rsrc(handle, smb_fname, true);
4751         } else {
4752                 return SMB_VFS_NEXT_STAT(handle, smb_fname);
4753         }
4754
4755         if (rc == 0) {
4756                 update_btime(handle, smb_fname);
4757                 smb_fname->st.st_ex_mode &= ~S_IFMT;
4758                 smb_fname->st.st_ex_mode |= S_IFREG;
4759                 smb_fname->st.st_ex_blocks =
4760                         smb_fname->st.st_ex_size / STAT_ST_BLOCKSIZE + 1;
4761         }
4762         return rc;
4763 }
4764
4765 static int fruit_lstat(vfs_handle_struct *handle,
4766                        struct smb_filename *smb_fname)
4767 {
4768         int rc = -1;
4769
4770         DEBUG(10, ("fruit_lstat called for %s\n",
4771                    smb_fname_str_dbg(smb_fname)));
4772
4773         if (!is_ntfs_stream_smb_fname(smb_fname)
4774             || is_ntfs_default_stream_smb_fname(smb_fname)) {
4775                 rc = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
4776                 if (rc == 0) {
4777                         update_btime(handle, smb_fname);
4778                 }
4779                 return rc;
4780         }
4781
4782         if (is_afpinfo_stream(smb_fname)) {
4783                 rc = fruit_stat_meta(handle, smb_fname, false);
4784         } else if (is_afpresource_stream(smb_fname)) {
4785                 rc = fruit_stat_rsrc(handle, smb_fname, false);
4786         } else {
4787                 return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
4788         }
4789
4790         if (rc == 0) {
4791                 update_btime(handle, smb_fname);
4792                 smb_fname->st.st_ex_mode &= ~S_IFMT;
4793                 smb_fname->st.st_ex_mode |= S_IFREG;
4794                 smb_fname->st.st_ex_blocks =
4795                         smb_fname->st.st_ex_size / STAT_ST_BLOCKSIZE + 1;
4796         }
4797         return rc;
4798 }
4799
4800 static int fruit_fstat_meta_stream(vfs_handle_struct *handle,
4801                                    files_struct *fsp,
4802                                    SMB_STRUCT_STAT *sbuf)
4803 {
4804         return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
4805 }
4806
4807 static int fruit_fstat_meta_netatalk(vfs_handle_struct *handle,
4808                                      files_struct *fsp,
4809                                      SMB_STRUCT_STAT *sbuf)
4810 {
4811         int ret;
4812
4813         ret = fruit_stat_base(handle, fsp->base_fsp->fsp_name, false);
4814         if (ret != 0) {
4815                 return -1;
4816         }
4817
4818         *sbuf = fsp->base_fsp->fsp_name->st;
4819         sbuf->st_ex_size = AFP_INFO_SIZE;
4820         sbuf->st_ex_ino = fruit_inode(sbuf, fsp->fsp_name->stream_name);
4821
4822         return 0;
4823 }
4824
4825 static int fruit_fstat_meta(vfs_handle_struct *handle,
4826                             files_struct *fsp,
4827                             SMB_STRUCT_STAT *sbuf,
4828                             struct fio *fio)
4829 {
4830         int ret;
4831
4832         DBG_DEBUG("Path [%s]\n", fsp_str_dbg(fsp));
4833
4834         switch (fio->config->meta) {
4835         case FRUIT_META_STREAM:
4836                 ret = fruit_fstat_meta_stream(handle, fsp, sbuf);
4837                 break;
4838
4839         case FRUIT_META_NETATALK:
4840                 ret = fruit_fstat_meta_netatalk(handle, fsp, sbuf);
4841                 break;
4842
4843         default:
4844                 DBG_ERR("Unexpected meta config [%d]\n", fio->config->meta);
4845                 return -1;
4846         }
4847
4848         DBG_DEBUG("Path [%s] ret [%d]\n", fsp_str_dbg(fsp), ret);
4849         return ret;
4850 }
4851
4852 static int fruit_fstat_rsrc_xattr(vfs_handle_struct *handle,
4853                                   files_struct *fsp,
4854                                   SMB_STRUCT_STAT *sbuf)
4855 {
4856         return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
4857 }
4858
4859 static int fruit_fstat_rsrc_stream(vfs_handle_struct *handle,
4860                                    files_struct *fsp,
4861                                    SMB_STRUCT_STAT *sbuf)
4862 {
4863         return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
4864 }
4865
4866 static int fruit_fstat_rsrc_adouble(vfs_handle_struct *handle,
4867                                     files_struct *fsp,
4868                                     SMB_STRUCT_STAT *sbuf)
4869 {
4870         struct adouble *ad = NULL;
4871         int ret;
4872
4873         /* Populate the stat struct with info from the base file. */
4874         ret = fruit_stat_base(handle, fsp->base_fsp->fsp_name, false);
4875         if (ret == -1) {
4876                 return -1;
4877         }
4878
4879         ad = ad_get(talloc_tos(), handle,
4880                     fsp->base_fsp->fsp_name,
4881                     ADOUBLE_RSRC);
4882         if (ad == NULL) {
4883                 DBG_ERR("ad_get [%s] failed [%s]\n",
4884                         fsp_str_dbg(fsp), strerror(errno));
4885                 return -1;
4886         }
4887
4888         *sbuf = fsp->base_fsp->fsp_name->st;
4889         sbuf->st_ex_size = ad_getentrylen(ad, ADEID_RFORK);
4890         sbuf->st_ex_ino = fruit_inode(sbuf, fsp->fsp_name->stream_name);
4891
4892         TALLOC_FREE(ad);
4893         return 0;
4894 }
4895
4896 static int fruit_fstat_rsrc(vfs_handle_struct *handle, files_struct *fsp,
4897                             SMB_STRUCT_STAT *sbuf, struct fio *fio)
4898 {
4899         int ret;
4900
4901         switch (fio->config->rsrc) {
4902         case FRUIT_RSRC_STREAM:
4903                 ret = fruit_fstat_rsrc_stream(handle, fsp, sbuf);
4904                 break;
4905
4906         case FRUIT_RSRC_ADFILE:
4907                 ret = fruit_fstat_rsrc_adouble(handle, fsp, sbuf);
4908                 break;
4909
4910         case FRUIT_RSRC_XATTR:
4911                 ret = fruit_fstat_rsrc_xattr(handle, fsp, sbuf);
4912                 break;
4913
4914         default:
4915                 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
4916                 return -1;
4917         }
4918
4919         return ret;
4920 }
4921
4922 static int fruit_fstat(vfs_handle_struct *handle, files_struct *fsp,
4923                        SMB_STRUCT_STAT *sbuf)
4924 {
4925         struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4926         int rc;
4927
4928         if (fio == NULL) {
4929                 return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
4930         }
4931
4932         DBG_DEBUG("Path [%s]\n", fsp_str_dbg(fsp));
4933
4934         if (fio->type == ADOUBLE_META) {
4935                 rc = fruit_fstat_meta(handle, fsp, sbuf, fio);
4936         } else {
4937                 rc = fruit_fstat_rsrc(handle, fsp, sbuf, fio);
4938         }
4939
4940         if (rc == 0) {
4941                 sbuf->st_ex_mode &= ~S_IFMT;
4942                 sbuf->st_ex_mode |= S_IFREG;
4943                 sbuf->st_ex_blocks = sbuf->st_ex_size / STAT_ST_BLOCKSIZE + 1;
4944         }
4945
4946         DBG_DEBUG("Path [%s] rc [%d] size [%"PRIdMAX"]\n",
4947                   fsp_str_dbg(fsp), rc, (intmax_t)sbuf->st_ex_size);
4948         return rc;
4949 }
4950
4951 static NTSTATUS delete_invalid_meta_stream(
4952         vfs_handle_struct *handle,
4953         const struct smb_filename *smb_fname,
4954         TALLOC_CTX *mem_ctx,
4955         unsigned int *pnum_streams,
4956         struct stream_struct **pstreams)
4957 {
4958         struct smb_filename *sname = NULL;
4959         int ret;
4960         bool ok;
4961
4962         ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams, AFPINFO_STREAM);
4963         if (!ok) {
4964                 return NT_STATUS_INTERNAL_ERROR;
4965         }
4966
4967         sname = synthetic_smb_fname(talloc_tos(),
4968                                     smb_fname->base_name,
4969                                     AFPINFO_STREAM_NAME,
4970                                     NULL, 0);
4971         if (sname == NULL) {
4972                 return NT_STATUS_NO_MEMORY;
4973         }
4974
4975         ret = SMB_VFS_NEXT_UNLINK(handle, sname);
4976         TALLOC_FREE(sname);
4977         if (ret != 0) {
4978                 DBG_ERR("Removing [%s] failed\n", smb_fname_str_dbg(sname));
4979                 return map_nt_error_from_unix(errno);
4980         }
4981
4982         return NT_STATUS_OK;
4983 }
4984
4985 static NTSTATUS fruit_streaminfo_meta_stream(
4986         vfs_handle_struct *handle,
4987         struct files_struct *fsp,
4988         const struct smb_filename *smb_fname,
4989         TALLOC_CTX *mem_ctx,
4990         unsigned int *pnum_streams,
4991         struct stream_struct **pstreams)
4992 {
4993         struct stream_struct *stream = *pstreams;
4994         unsigned int num_streams = *pnum_streams;
4995         struct smb_filename *sname = NULL;
4996         char *full_name = NULL;
4997         uint32_t name_hash;
4998         struct share_mode_lock *lck = NULL;
4999         struct file_id id = {0};
5000         bool delete_on_close_set;
5001         int i;
5002         int ret;
5003         NTSTATUS status;
5004         bool ok;
5005
5006         for (i = 0; i < num_streams; i++) {
5007                 if (strequal_m(stream[i].name, AFPINFO_STREAM)) {
5008                         break;
5009                 }
5010         }
5011
5012         if (i == num_streams) {
5013                 return NT_STATUS_OK;
5014         }
5015
5016         if (stream[i].size != AFP_INFO_SIZE) {
5017                 DBG_ERR("Removing invalid AFPINFO_STREAM size [%jd] from [%s]\n",
5018                         (intmax_t)stream[i].size, smb_fname_str_dbg(smb_fname));
5019
5020                 return delete_invalid_meta_stream(handle, smb_fname, mem_ctx,
5021                                                   pnum_streams, pstreams);
5022         }
5023
5024         /*
5025          * Now check if there's a delete-on-close pending on the stream. If so,
5026          * hide the stream. This behaviour was verified against a macOS 10.12
5027          * SMB server.
5028          */
5029
5030         sname = synthetic_smb_fname(talloc_tos(),
5031                                     smb_fname->base_name,
5032                                     AFPINFO_STREAM_NAME,
5033                                     NULL, 0);
5034         if (sname == NULL) {
5035                 status = NT_STATUS_NO_MEMORY;
5036                 goto out;
5037         }
5038
5039         ret = SMB_VFS_NEXT_STAT(handle, sname);
5040         if (ret != 0) {
5041                 status = map_nt_error_from_unix(errno);
5042                 goto out;
5043         }
5044
5045         id = SMB_VFS_NEXT_FILE_ID_CREATE(handle, &sname->st);
5046
5047         lck = get_existing_share_mode_lock(talloc_tos(), id);
5048         if (lck == NULL) {
5049                 status = NT_STATUS_OK;
5050                 goto out;
5051         }
5052
5053         full_name = talloc_asprintf(talloc_tos(),
5054                                     "%s%s",
5055                                     sname->base_name,
5056                                     AFPINFO_STREAM);
5057         if (full_name == NULL) {
5058                 status = NT_STATUS_NO_MEMORY;
5059                 goto out;
5060         }
5061
5062         status = file_name_hash(handle->conn, full_name, &name_hash);
5063         if (!NT_STATUS_IS_OK(status)) {
5064                 goto out;
5065         }
5066
5067         delete_on_close_set = is_delete_on_close_set(lck, name_hash);
5068         if (delete_on_close_set) {
5069                 ok = del_fruit_stream(mem_ctx,
5070                                       pnum_streams,
5071                                       pstreams,
5072                                       AFPINFO_STREAM);
5073                 if (!ok) {
5074                         status = NT_STATUS_INTERNAL_ERROR;
5075                         goto out;
5076                 }
5077         }
5078
5079         status  = NT_STATUS_OK;
5080
5081 out:
5082         TALLOC_FREE(sname);
5083         TALLOC_FREE(lck);
5084         TALLOC_FREE(full_name);
5085         return status;
5086 }
5087
5088 static NTSTATUS fruit_streaminfo_meta_netatalk(
5089         vfs_handle_struct *handle,
5090         struct files_struct *fsp,
5091         const struct smb_filename *smb_fname,
5092         TALLOC_CTX *mem_ctx,
5093         unsigned int *pnum_streams,
5094         struct stream_struct **pstreams)
5095 {
5096         struct stream_struct *stream = *pstreams;
5097         unsigned int num_streams = *pnum_streams;
5098         struct adouble *ad = NULL;
5099         bool is_fi_empty;
5100         int i;
5101         bool ok;
5102
5103         /* Remove the Netatalk xattr from the list */
5104         ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams,
5105                               ":" NETATALK_META_XATTR ":$DATA");
5106         if (!ok) {
5107                 return NT_STATUS_NO_MEMORY;
5108         }
5109
5110         /*
5111          * Check if there's a AFPINFO_STREAM from the VFS streams
5112          * backend and if yes, remove it from the list
5113          */
5114         for (i = 0; i < num_streams; i++) {
5115                 if (strequal_m(stream[i].name, AFPINFO_STREAM)) {
5116                         break;
5117                 }
5118         }
5119
5120         if (i < num_streams) {
5121                 DBG_WARNING("Unexpected AFPINFO_STREAM on [%s]\n",
5122                             smb_fname_str_dbg(smb_fname));
5123
5124                 ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams,
5125                                       AFPINFO_STREAM);
5126                 if (!ok) {
5127                         return NT_STATUS_INTERNAL_ERROR;
5128                 }
5129         }
5130
5131         ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_META);
5132         if (ad == NULL) {
5133                 return NT_STATUS_OK;
5134         }
5135
5136         is_fi_empty = ad_empty_finderinfo(ad);
5137         TALLOC_FREE(ad);
5138
5139         if (is_fi_empty) {
5140                 return NT_STATUS_OK;
5141         }
5142
5143         ok = add_fruit_stream(mem_ctx, pnum_streams, pstreams,
5144                               AFPINFO_STREAM_NAME, AFP_INFO_SIZE,
5145                               smb_roundup(handle->conn, AFP_INFO_SIZE));
5146         if (!ok) {
5147                 return NT_STATUS_NO_MEMORY;
5148         }
5149
5150         return NT_STATUS_OK;
5151 }
5152
5153 static NTSTATUS fruit_streaminfo_meta(vfs_handle_struct *handle,
5154                                       struct files_struct *fsp,
5155                                       const struct smb_filename *smb_fname,
5156                                       TALLOC_CTX *mem_ctx,
5157                                       unsigned int *pnum_streams,
5158                                       struct stream_struct **pstreams)
5159 {
5160         struct fruit_config_data *config = NULL;
5161         NTSTATUS status;
5162
5163         SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
5164                                 return NT_STATUS_INTERNAL_ERROR);
5165
5166         switch (config->meta) {
5167         case FRUIT_META_NETATALK:
5168                 status = fruit_streaminfo_meta_netatalk(handle, fsp, smb_fname,
5169                                                         mem_ctx, pnum_streams,
5170                                                         pstreams);
5171                 break;
5172
5173         case FRUIT_META_STREAM:
5174                 status = fruit_streaminfo_meta_stream(handle, fsp, smb_fname,
5175                                                       mem_ctx, pnum_streams,
5176                                                       pstreams);
5177                 break;
5178
5179         default:
5180                 return NT_STATUS_INTERNAL_ERROR;
5181         }
5182
5183         return status;
5184 }
5185
5186 static NTSTATUS fruit_streaminfo_rsrc_stream(
5187         vfs_handle_struct *handle,
5188         struct files_struct *fsp,
5189         const struct smb_filename *smb_fname,
5190         TALLOC_CTX *mem_ctx,
5191         unsigned int *pnum_streams,
5192         struct stream_struct **pstreams)
5193 {
5194         bool ok;
5195
5196         ok = filter_empty_rsrc_stream(pnum_streams, pstreams);
5197         if (!ok) {
5198                 DBG_ERR("Filtering resource stream failed\n");
5199                 return NT_STATUS_INTERNAL_ERROR;
5200         }
5201         return NT_STATUS_OK;
5202 }
5203
5204 static NTSTATUS fruit_streaminfo_rsrc_xattr(
5205         vfs_handle_struct *handle,
5206         struct files_struct *fsp,
5207         const struct smb_filename *smb_fname,
5208         TALLOC_CTX *mem_ctx,
5209         unsigned int *pnum_streams,
5210         struct stream_struct **pstreams)
5211 {
5212         bool ok;
5213
5214         ok = filter_empty_rsrc_stream(pnum_streams, pstreams);
5215         if (!ok) {
5216                 DBG_ERR("Filtering resource stream failed\n");
5217                 return NT_STATUS_INTERNAL_ERROR;
5218         }
5219         return NT_STATUS_OK;
5220 }
5221
5222 static NTSTATUS fruit_streaminfo_rsrc_adouble(
5223         vfs_handle_struct *handle,
5224         struct files_struct *fsp,
5225         const struct smb_filename *smb_fname,
5226         TALLOC_CTX *mem_ctx,
5227         unsigned int *pnum_streams,
5228         struct stream_struct **pstreams)
5229 {
5230         struct stream_struct *stream = *pstreams;
5231         unsigned int num_streams = *pnum_streams;
5232         struct adouble *ad = NULL;
5233         bool ok;
5234         size_t rlen;
5235         int i;
5236
5237         /*
5238          * Check if there's a AFPRESOURCE_STREAM from the VFS streams backend
5239          * and if yes, remove it from the list
5240          */
5241         for (i = 0; i < num_streams; i++) {
5242                 if (strequal_m(stream[i].name, AFPRESOURCE_STREAM)) {
5243                         break;
5244                 }
5245         }
5246
5247         if (i < num_streams) {
5248                 DBG_WARNING("Unexpected AFPRESOURCE_STREAM on [%s]\n",
5249                             smb_fname_str_dbg(smb_fname));
5250
5251                 ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams,
5252                                       AFPRESOURCE_STREAM);
5253                 if (!ok) {
5254                         return NT_STATUS_INTERNAL_ERROR;
5255                 }
5256         }
5257
5258         ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_RSRC);
5259         if (ad == NULL) {
5260                 return NT_STATUS_OK;
5261         }
5262
5263         rlen = ad_getentrylen(ad, ADEID_RFORK);
5264         TALLOC_FREE(ad);
5265
5266         if (rlen == 0) {
5267                 return NT_STATUS_OK;
5268         }
5269
5270         ok = add_fruit_stream(mem_ctx, pnum_streams, pstreams,
5271                               AFPRESOURCE_STREAM_NAME, rlen,
5272                               smb_roundup(handle->conn, rlen));
5273         if (!ok) {
5274                 return NT_STATUS_NO_MEMORY;
5275         }
5276
5277         return NT_STATUS_OK;
5278 }
5279
5280 static NTSTATUS fruit_streaminfo_rsrc(vfs_handle_struct *handle,
5281                                       struct files_struct *fsp,
5282                                       const struct smb_filename *smb_fname,
5283                                       TALLOC_CTX *mem_ctx,
5284                                       unsigned int *pnum_streams,
5285                                       struct stream_struct **pstreams)
5286 {
5287         struct fruit_config_data *config = NULL;
5288         NTSTATUS status;
5289
5290         SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
5291                                 return NT_STATUS_INTERNAL_ERROR);
5292
5293         switch (config->rsrc) {
5294         case FRUIT_RSRC_STREAM:
5295                 status = fruit_streaminfo_rsrc_stream(handle, fsp, smb_fname,
5296                                                       mem_ctx, pnum_streams,
5297                                                       pstreams);
5298                 break;
5299
5300         case FRUIT_RSRC_XATTR:
5301                 status = fruit_streaminfo_rsrc_xattr(handle, fsp, smb_fname,
5302                                                      mem_ctx, pnum_streams,
5303                                                      pstreams);
5304                 break;
5305
5306         case FRUIT_RSRC_ADFILE:
5307                 status = fruit_streaminfo_rsrc_adouble(handle, fsp, smb_fname,
5308                                                        mem_ctx, pnum_streams,
5309                                                        pstreams);
5310                 break;
5311
5312         default:
5313                 return NT_STATUS_INTERNAL_ERROR;
5314         }
5315
5316         return status;
5317 }
5318
5319 static NTSTATUS fruit_streaminfo(vfs_handle_struct *handle,
5320                                  struct files_struct *fsp,
5321                                  const struct smb_filename *smb_fname,
5322                                  TALLOC_CTX *mem_ctx,
5323                                  unsigned int *pnum_streams,
5324                                  struct stream_struct **pstreams)
5325 {
5326         struct fruit_config_data *config = NULL;
5327         NTSTATUS status;
5328
5329         SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
5330                                 return NT_STATUS_UNSUCCESSFUL);
5331
5332         DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
5333
5334         status = SMB_VFS_NEXT_STREAMINFO(handle, fsp, smb_fname, mem_ctx,
5335                                          pnum_streams, pstreams);
5336         if (!NT_STATUS_IS_OK(status)) {
5337                 return status;
5338         }
5339
5340         status = fruit_streaminfo_meta(handle, fsp, smb_fname,
5341                                        mem_ctx, pnum_streams, pstreams);
5342         if (!NT_STATUS_IS_OK(status)) {
5343                 return status;
5344         }
5345
5346         status = fruit_streaminfo_rsrc(handle, fsp, smb_fname,
5347                                        mem_ctx, pnum_streams, pstreams);
5348         if (!NT_STATUS_IS_OK(status)) {
5349                 return status;
5350         }
5351
5352         return NT_STATUS_OK;
5353 }
5354
5355 static int fruit_ntimes(vfs_handle_struct *handle,
5356                         const struct smb_filename *smb_fname,
5357                         struct smb_file_time *ft)
5358 {
5359         int rc = 0;
5360         struct adouble *ad = NULL;
5361         struct fruit_config_data *config = NULL;
5362
5363         SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
5364                                 return -1);
5365
5366         if ((config->meta != FRUIT_META_NETATALK) ||
5367             null_timespec(ft->create_time))
5368         {
5369                 return SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
5370         }
5371
5372         DEBUG(10,("set btime for %s to %s\n", smb_fname_str_dbg(smb_fname),
5373                  time_to_asc(convert_timespec_to_time_t(ft->create_time))));
5374
5375         ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_META);
5376         if (ad == NULL) {
5377                 goto exit;
5378         }
5379
5380         ad_setdate(ad, AD_DATE_CREATE | AD_DATE_UNIX,
5381                    convert_time_t_to_uint32_t(ft->create_time.tv_sec));
5382
5383         rc = ad_set(ad, smb_fname);
5384
5385 exit:
5386
5387         TALLOC_FREE(ad);
5388         if (rc != 0) {
5389                 DEBUG(1, ("fruit_ntimes: %s\n", smb_fname_str_dbg(smb_fname)));
5390                 return -1;
5391         }
5392         return SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
5393 }
5394
5395 static int fruit_fallocate(struct vfs_handle_struct *handle,
5396                            struct files_struct *fsp,
5397                            uint32_t mode,
5398                            off_t offset,
5399                            off_t len)
5400 {
5401         struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
5402
5403         if (fio == NULL) {
5404                 return SMB_VFS_NEXT_FALLOCATE(handle, fsp, mode, offset, len);
5405         }
5406
5407         /* Let the pwrite code path handle it. */
5408         errno = ENOSYS;
5409         return -1;
5410 }
5411
5412 static int fruit_ftruncate_rsrc_xattr(struct vfs_handle_struct *handle,
5413                                       struct files_struct *fsp,
5414                                       off_t offset)
5415 {
5416         if (offset == 0) {
5417                 return SMB_VFS_FREMOVEXATTR(fsp, AFPRESOURCE_EA_NETATALK);
5418         }
5419
5420 #ifdef HAVE_ATTROPEN
5421         return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
5422 #endif
5423         return 0;
5424 }
5425
5426 static int fruit_ftruncate_rsrc_adouble(struct vfs_handle_struct *handle,
5427                                         struct files_struct *fsp,
5428                                         off_t offset)
5429 {
5430         int rc;
5431         struct adouble *ad = NULL;
5432         off_t ad_off;
5433
5434         ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_RSRC);
5435         if (ad == NULL) {
5436                 DBG_DEBUG("ad_get [%s] failed [%s]\n",
5437                           fsp_str_dbg(fsp), strerror(errno));
5438                 return -1;
5439         }
5440
5441         ad_off = ad_getentryoff(ad, ADEID_RFORK);
5442
5443         rc = ftruncate(fsp->fh->fd, offset + ad_off);
5444         if (rc != 0) {
5445                 TALLOC_FREE(ad);
5446                 return -1;
5447         }
5448
5449         ad_setentrylen(ad, ADEID_RFORK, offset);
5450
5451         rc = ad_fset(ad, fsp);
5452         if (rc != 0) {
5453                 DBG_ERR("ad_fset [%s] failed [%s]\n",
5454                         fsp_str_dbg(fsp), strerror(errno));
5455                 TALLOC_FREE(ad);
5456                 return -1;
5457         }
5458
5459         TALLOC_FREE(ad);
5460         return 0;
5461 }
5462
5463 static int fruit_ftruncate_rsrc_stream(struct vfs_handle_struct *handle,
5464                                        struct files_struct *fsp,
5465                                        off_t offset)
5466 {
5467         if (offset == 0) {
5468                 return SMB_VFS_NEXT_UNLINK(handle, fsp->fsp_name);
5469         }
5470
5471         return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
5472 }
5473
5474 static int fruit_ftruncate_rsrc(struct vfs_handle_struct *handle,
5475                                 struct files_struct *fsp,
5476                                 off_t offset)
5477 {
5478         struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
5479         int ret;
5480
5481         switch (fio->config->rsrc) {
5482         case FRUIT_RSRC_XATTR:
5483                 ret = fruit_ftruncate_rsrc_xattr(handle, fsp, offset);
5484                 break;
5485
5486         case FRUIT_RSRC_ADFILE:
5487                 ret = fruit_ftruncate_rsrc_adouble(handle, fsp, offset);
5488                 break;
5489
5490         case FRUIT_RSRC_STREAM:
5491                 ret = fruit_ftruncate_rsrc_stream(handle, fsp, offset);
5492                 break;
5493
5494         default:
5495                 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
5496                 return -1;
5497         }
5498
5499
5500         return ret;
5501 }
5502
5503 static int fruit_ftruncate_meta(struct vfs_handle_struct *handle,
5504                                 struct files_struct *fsp,
5505                                 off_t offset)
5506 {
5507         if (offset > 60) {
5508                 DBG_WARNING("ftruncate %s to %jd",
5509                             fsp_str_dbg(fsp), (intmax_t)offset);
5510                 /* OS X returns NT_STATUS_ALLOTTED_SPACE_EXCEEDED  */
5511                 errno = EOVERFLOW;
5512                 return -1;
5513         }
5514
5515         /* OS X returns success but does nothing  */
5516         DBG_INFO("ignoring ftruncate %s to %jd\n",
5517                  fsp_str_dbg(fsp), (intmax_t)offset);
5518         return 0;
5519 }
5520
5521 static int fruit_ftruncate(struct vfs_handle_struct *handle,
5522                            struct files_struct *fsp,
5523                            off_t offset)
5524 {
5525         struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
5526         int ret;
5527
5528         DBG_DEBUG("Path [%s] offset [%"PRIdMAX"]\n", fsp_str_dbg(fsp),
5529                   (intmax_t)offset);
5530
5531         if (fio == NULL) {
5532                 return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
5533         }
5534
5535         if (fio->type == ADOUBLE_META) {
5536                 ret = fruit_ftruncate_meta(handle, fsp, offset);
5537         } else {
5538                 ret = fruit_ftruncate_rsrc(handle, fsp, offset);
5539         }
5540
5541         DBG_DEBUG("Path [%s] result [%d]\n", fsp_str_dbg(fsp), ret);
5542         return ret;
5543 }
5544
5545 static NTSTATUS fruit_create_file(vfs_handle_struct *handle,
5546                                   struct smb_request *req,
5547                                   uint16_t root_dir_fid,
5548                                   struct smb_filename *smb_fname,
5549                                   uint32_t access_mask,
5550                                   uint32_t share_access,
5551                                   uint32_t create_disposition,
5552                                   uint32_t create_options,
5553                                   uint32_t file_attributes,
5554                                   uint32_t oplock_request,
5555                                   struct smb2_lease *lease,
5556                                   uint64_t allocation_size,
5557                                   uint32_t private_flags,
5558                                   struct security_descriptor *sd,
5559                                   struct ea_list *ea_list,
5560                                   files_struct **result,
5561                                   int *pinfo,
5562                                   const struct smb2_create_blobs *in_context_blobs,
5563                                   struct smb2_create_blobs *out_context_blobs)
5564 {
5565         NTSTATUS status;
5566         struct fruit_config_data *config = NULL;
5567         files_struct *fsp = NULL;
5568
5569         status = check_aapl(handle, req, in_context_blobs, out_context_blobs);
5570         if (!NT_STATUS_IS_OK(status)) {
5571                 goto fail;
5572         }
5573
5574         SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
5575                                 return NT_STATUS_UNSUCCESSFUL);
5576
5577         status = SMB_VFS_NEXT_CREATE_FILE(
5578                 handle, req, root_dir_fid, smb_fname,
5579                 access_mask, share_access,
5580                 create_disposition, create_options,
5581                 file_attributes, oplock_request,
5582                 lease,
5583                 allocation_size, private_flags,
5584                 sd, ea_list, result,
5585                 pinfo, in_context_blobs, out_context_blobs);
5586         if (!NT_STATUS_IS_OK(status)) {
5587                 return status;
5588         }
5589
5590         fsp = *result;
5591
5592         if (global_fruit_config.nego_aapl) {
5593                 if (config->posix_rename && fsp->is_directory) {
5594                         /*
5595                          * Enable POSIX directory rename behaviour
5596                          */
5597                         fsp->posix_flags |= FSP_POSIX_FLAGS_RENAME;
5598                 }
5599         }
5600
5601         /*
5602          * If this is a plain open for existing files, opening an 0
5603          * byte size resource fork MUST fail with
5604          * NT_STATUS_OBJECT_NAME_NOT_FOUND.
5605          *
5606          * Cf the vfs_fruit torture tests in test_rfork_create().
5607          */
5608         if (is_afpresource_stream(fsp->fsp_name) &&
5609             create_disposition == FILE_OPEN)
5610         {
5611                 if (fsp->fsp_name->st.st_ex_size == 0) {
5612                         status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
5613                         goto fail;
5614                 }
5615         }
5616
5617         if (is_ntfs_stream_smb_fname(smb_fname)
5618             || fsp->is_directory) {
5619                 return status;
5620         }
5621
5622         if (config->locking == FRUIT_LOCKING_NETATALK) {
5623                 status = fruit_check_access(
5624                         handle, *result,
5625                         access_mask,
5626                         map_share_mode_to_deny_mode(share_access, 0));
5627                 if (!NT_STATUS_IS_OK(status)) {
5628                         goto fail;
5629                 }
5630         }
5631
5632         return status;
5633
5634 fail:
5635         DEBUG(10, ("fruit_create_file: %s\n", nt_errstr(status)));
5636
5637         if (fsp) {
5638                 close_file(req, fsp, ERROR_CLOSE);
5639                 *result = fsp = NULL;
5640         }
5641
5642         return status;
5643 }
5644
5645 static NTSTATUS fruit_readdir_attr(struct vfs_handle_struct *handle,
5646                                    const struct smb_filename *fname,
5647                                    TALLOC_CTX *mem_ctx,
5648                                    struct readdir_attr_data **pattr_data)
5649 {
5650         struct fruit_config_data *config = NULL;
5651         struct readdir_attr_data *attr_data;
5652         NTSTATUS status;
5653
5654         SMB_VFS_HANDLE_GET_DATA(handle, config,
5655                                 struct fruit_config_data,
5656                                 return NT_STATUS_UNSUCCESSFUL);
5657
5658         if (!global_fruit_config.nego_aapl) {
5659                 return SMB_VFS_NEXT_READDIR_ATTR(handle, fname, mem_ctx, pattr_data);
5660         }
5661
5662         DEBUG(10, ("fruit_readdir_attr %s\n", fname->base_name));
5663
5664         *pattr_data = talloc_zero(mem_ctx, struct readdir_attr_data);
5665         if (*pattr_data == NULL) {
5666                 return NT_STATUS_UNSUCCESSFUL;
5667         }
5668         attr_data = *pattr_data;
5669         attr_data->type = RDATTR_AAPL;
5670
5671         /*
5672          * Mac metadata: compressed FinderInfo, resource fork length
5673          * and creation date
5674          */
5675         status = readdir_attr_macmeta(handle, fname, attr_data);
5676         if (!NT_STATUS_IS_OK(status)) {
5677                 /*
5678                  * Error handling is tricky: if we return failure from
5679                  * this function, the corresponding directory entry
5680                  * will to be passed to the client, so we really just
5681                  * want to error out on fatal errors.
5682                  */
5683                 if  (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
5684                         goto fail;
5685                 }
5686         }
5687
5688         /*
5689          * UNIX mode
5690          */
5691         if (config->unix_info_enabled) {
5692                 attr_data->attr_data.aapl.unix_mode = fname->st.st_ex_mode;
5693         }
5694
5695         /*
5696          * max_access
5697          */
5698         if (!config->readdir_attr_max_access) {
5699                 attr_data->attr_data.aapl.max_access = FILE_GENERIC_ALL;
5700         } else {
5701                 status = smbd_calculate_access_mask(
5702                         handle->conn,
5703                         fname,
5704                         false,
5705                         SEC_FLAG_MAXIMUM_ALLOWED,
5706                         &attr_data->attr_data.aapl.max_access);
5707                 if (!NT_STATUS_IS_OK(status)) {
5708                         goto fail;
5709                 }
5710         }
5711
5712         return NT_STATUS_OK;
5713
5714 fail:
5715         DEBUG(1, ("fruit_readdir_attr %s, error: %s\n",
5716                   fname->base_name, nt_errstr(status)));
5717         TALLOC_FREE(*pattr_data);
5718         return status;
5719 }
5720
5721 static NTSTATUS fruit_fget_nt_acl(vfs_handle_struct *handle,
5722                                   files_struct *fsp,
5723                                   uint32_t security_info,
5724                                   TALLOC_CTX *mem_ctx,
5725                                   struct security_descriptor **ppdesc)
5726 {
5727         NTSTATUS status;
5728         struct security_ace ace;
5729         struct dom_sid sid;
5730         struct fruit_config_data *config;
5731         bool remove_ok = false;
5732
5733         SMB_VFS_HANDLE_GET_DATA(handle, config,
5734                                 struct fruit_config_data,
5735                                 return NT_STATUS_UNSUCCESSFUL);
5736
5737         status = SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info,
5738                                           mem_ctx, ppdesc);
5739         if (!NT_STATUS_IS_OK(status)) {
5740                 return status;
5741         }
5742
5743         /*
5744          * Add MS NFS style ACEs with uid, gid and mode
5745          */
5746         if (!global_fruit_config.nego_aapl) {
5747                 return NT_STATUS_OK;
5748         }
5749         if (!config->unix_info_enabled) {
5750                 return NT_STATUS_OK;
5751         }
5752
5753         /* MS NFS style mode */
5754         sid_compose(&sid, &global_sid_Unix_NFS_Mode, fsp->fsp_name->st.st_ex_mode);
5755         init_sec_ace(&ace, &sid, SEC_ACE_TYPE_ACCESS_DENIED, 0, 0);
5756
5757         /* First remove any existing ACE's with this SID. */
5758         status = security_descriptor_dacl_del(*ppdesc, &sid);
5759         remove_ok = (NT_STATUS_IS_OK(status) ||
5760                      NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND));
5761         if (!remove_ok) {
5762                 DBG_WARNING("failed to remove MS NFS_mode style ACE\n");
5763                 return status;
5764         }
5765         status = security_descriptor_dacl_add(*ppdesc, &ace);
5766         if (!NT_STATUS_IS_OK(status)) {
5767                 DEBUG(1,("failed to add MS NFS style ACE\n"));
5768                 return status;
5769         }
5770
5771         /* MS NFS style uid */
5772         sid_compose(&sid, &global_sid_Unix_NFS_Users, fsp->fsp_name->st.st_ex_uid);
5773         init_sec_ace(&ace, &sid, SEC_ACE_TYPE_ACCESS_DENIED, 0, 0);
5774
5775         /* First remove any existing ACE's with this SID. */
5776         status = security_descriptor_dacl_del(*ppdesc, &sid);
5777         remove_ok = (NT_STATUS_IS_OK(status) ||
5778                      NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND));
5779         if (!remove_ok) {
5780                 DBG_WARNING("failed to remove MS NFS_users style ACE\n");
5781                 return status;
5782         }
5783         status = security_descriptor_dacl_add(*ppdesc, &ace);
5784         if (!NT_STATUS_IS_OK(status)) {
5785                 DEBUG(1,("failed to add MS NFS style ACE\n"));
5786                 return status;
5787         }
5788
5789         /* MS NFS style gid */
5790         sid_compose(&sid, &global_sid_Unix_NFS_Groups, fsp->fsp_name->st.st_ex_gid);
5791         init_sec_ace(&ace, &sid, SEC_ACE_TYPE_ACCESS_DENIED, 0, 0);
5792
5793         /* First remove any existing ACE's with this SID. */
5794         status = security_descriptor_dacl_del(*ppdesc, &sid);
5795         remove_ok = (NT_STATUS_IS_OK(status) ||
5796                      NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND));
5797         if (!remove_ok) {
5798                 DBG_WARNING("failed to remove MS NFS_groups style ACE\n");
5799                 return status;
5800         }
5801         status = security_descriptor_dacl_add(*ppdesc, &ace);
5802         if (!NT_STATUS_IS_OK(status)) {
5803                 DEBUG(1,("failed to add MS NFS style ACE\n"));
5804                 return status;
5805         }
5806
5807         return NT_STATUS_OK;
5808 }
5809
5810 static NTSTATUS fruit_fset_nt_acl(vfs_handle_struct *handle,
5811                                   files_struct *fsp,
5812                                   uint32_t security_info_sent,
5813                                   const struct security_descriptor *orig_psd)
5814 {
5815         NTSTATUS status;
5816         bool do_chmod;
5817         mode_t ms_nfs_mode = 0;
5818         int result;
5819         struct security_descriptor *psd = NULL;
5820         uint32_t orig_num_aces = 0;
5821
5822         if (orig_psd->dacl != NULL) {
5823                 orig_num_aces = orig_psd->dacl->num_aces;
5824         }
5825
5826         psd = security_descriptor_copy(talloc_tos(), orig_psd);
5827         if (psd == NULL) {
5828                 return NT_STATUS_NO_MEMORY;
5829         }
5830
5831         DBG_DEBUG("fruit_fset_nt_acl: %s\n", fsp_str_dbg(fsp));
5832
5833         status = check_ms_nfs(handle, fsp, psd, &ms_nfs_mode, &do_chmod);
5834         if (!NT_STATUS_IS_OK(status)) {
5835                 DEBUG(1, ("fruit_fset_nt_acl: check_ms_nfs failed%s\n", fsp_str_dbg(fsp)));
5836                 TALLOC_FREE(psd);
5837                 return status;
5838         }
5839
5840         /*
5841          * If only ms_nfs ACE entries were sent, ensure we set the DACL
5842          * sent/present flags correctly now we've removed them.
5843          */
5844
5845         if (orig_num_aces != 0) {
5846                 /*
5847                  * Are there any ACE's left ?
5848                  */
5849                 if (psd->dacl->num_aces == 0) {
5850                         /* No - clear the DACL sent/present flags. */
5851                         security_info_sent &= ~SECINFO_DACL;
5852                         psd->type &= ~SEC_DESC_DACL_PRESENT;
5853                 }
5854         }
5855
5856         status = SMB_VFS_NEXT_FSET_NT_ACL(handle, fsp, security_info_sent, psd);
5857         if (!NT_STATUS_IS_OK(status)) {
5858                 DEBUG(1, ("fruit_fset_nt_acl: SMB_VFS_NEXT_FSET_NT_ACL failed%s\n", fsp_str_dbg(fsp)));
5859                 TALLOC_FREE(psd);
5860                 return status;
5861         }
5862
5863         if (do_chmod) {
5864                 if (fsp->fh->fd != -1) {
5865                         result = SMB_VFS_FCHMOD(fsp, ms_nfs_mode);
5866                 } else {
5867                         result = SMB_VFS_CHMOD(fsp->conn,
5868                                                fsp->fsp_name,
5869                                                ms_nfs_mode);
5870                 }
5871
5872                 if (result != 0) {
5873                         DEBUG(1, ("chmod: %s, result: %d, %04o error %s\n", fsp_str_dbg(fsp),
5874                                   result, (unsigned)ms_nfs_mode,
5875                                   strerror(errno)));
5876                         status = map_nt_error_from_unix(errno);
5877                         TALLOC_FREE(psd);
5878                         return status;
5879                 }
5880         }
5881
5882         TALLOC_FREE(psd);
5883         return NT_STATUS_OK;
5884 }
5885
5886 static struct vfs_offload_ctx *fruit_offload_ctx;
5887
5888 struct fruit_offload_read_state {
5889         struct vfs_handle_struct *handle;
5890         struct tevent_context *ev;
5891         files_struct *fsp;
5892         uint32_t fsctl;
5893         DATA_BLOB token;
5894 };
5895
5896 static void fruit_offload_read_done(struct tevent_req *subreq);
5897
5898 static struct tevent_req *fruit_offload_read_send(
5899         TALLOC_CTX *mem_ctx,
5900         struct tevent_context *ev,
5901         struct vfs_handle_struct *handle,
5902         files_struct *fsp,
5903         uint32_t fsctl,
5904         uint32_t ttl,
5905         off_t offset,
5906         size_t to_copy)
5907 {
5908         struct tevent_req *req = NULL;
5909         struct tevent_req *subreq = NULL;
5910         struct fruit_offload_read_state *state = NULL;
5911
5912         req = tevent_req_create(mem_ctx, &state,
5913                                 struct fruit_offload_read_state);
5914         if (req == NULL) {
5915                 return NULL;
5916         }
5917         *state = (struct fruit_offload_read_state) {
5918                 .handle = handle,
5919                 .ev = ev,
5920                 .fsp = fsp,
5921                 .fsctl = fsctl,
5922         };
5923
5924         subreq = SMB_VFS_NEXT_OFFLOAD_READ_SEND(mem_ctx, ev, handle, fsp,
5925                                                 fsctl, ttl, offset, to_copy);
5926         if (tevent_req_nomem(subreq, req)) {
5927                 return tevent_req_post(req, ev);
5928         }
5929         tevent_req_set_callback(subreq, fruit_offload_read_done, req);
5930         return req;
5931 }
5932
5933 static void fruit_offload_read_done(struct tevent_req *subreq)
5934 {
5935         struct tevent_req *req = tevent_req_callback_data(
5936                 subreq, struct tevent_req);
5937         struct fruit_offload_read_state *state = tevent_req_data(
5938                 req, struct fruit_offload_read_state);
5939         NTSTATUS status;
5940
5941         status = SMB_VFS_NEXT_OFFLOAD_READ_RECV(subreq,
5942                                                 state->handle,
5943                                                 state,
5944                                                 &state->token);
5945         TALLOC_FREE(subreq);
5946         if (tevent_req_nterror(req, status)) {
5947                 return;
5948         }
5949
5950         if (state->fsctl != FSCTL_SRV_REQUEST_RESUME_KEY) {
5951                 tevent_req_done(req);
5952                 return;
5953         }
5954
5955         status = vfs_offload_token_ctx_init(state->fsp->conn->sconn->client,
5956                                             &fruit_offload_ctx);
5957         if (tevent_req_nterror(req, status)) {
5958                 return;
5959         }
5960
5961         status = vfs_offload_token_db_store_fsp(fruit_offload_ctx,
5962                                                 state->fsp,
5963                                                 &state->token);
5964         if (tevent_req_nterror(req, status)) {
5965                 return;
5966         }
5967
5968         tevent_req_done(req);
5969         return;
5970 }
5971
5972 static NTSTATUS fruit_offload_read_recv(struct tevent_req *req,
5973                                         struct vfs_handle_struct *handle,
5974                                         TALLOC_CTX *mem_ctx,
5975                                         DATA_BLOB *token)
5976 {
5977         struct fruit_offload_read_state *state = tevent_req_data(
5978                 req, struct fruit_offload_read_state);
5979         NTSTATUS status;
5980
5981         if (tevent_req_is_nterror(req, &status)) {
5982                 tevent_req_received(req);
5983                 return status;
5984         }
5985
5986         token->length = state->token.length;
5987         token->data = talloc_move(mem_ctx, &state->token.data);
5988
5989         tevent_req_received(req);
5990         return NT_STATUS_OK;
5991 }
5992
5993 struct fruit_offload_write_state {
5994         struct vfs_handle_struct *handle;
5995         off_t copied;
5996         struct files_struct *src_fsp;
5997         struct files_struct *dst_fsp;
5998         bool is_copyfile;
5999 };
6000
6001 static void fruit_offload_write_done(struct tevent_req *subreq);
6002 static struct tevent_req *fruit_offload_write_send(struct vfs_handle_struct *handle,
6003                                                 TALLOC_CTX *mem_ctx,
6004                                                 struct tevent_context *ev,
6005                                                 uint32_t fsctl,
6006                                                 DATA_BLOB *token,
6007                                                 off_t transfer_offset,
6008                                                 struct files_struct *dest_fsp,
6009                                                 off_t dest_off,
6010                                                 off_t num)
6011 {
6012         struct tevent_req *req, *subreq;
6013         struct fruit_offload_write_state *state;
6014         NTSTATUS status;
6015         struct fruit_config_data *config;
6016         off_t src_off = transfer_offset;
6017         files_struct *src_fsp = NULL;
6018         off_t to_copy = num;
6019         bool copyfile_enabled = false;
6020
6021         DEBUG(10,("soff: %ju, doff: %ju, len: %ju\n",
6022                   (uintmax_t)src_off, (uintmax_t)dest_off, (uintmax_t)num));
6023
6024         SMB_VFS_HANDLE_GET_DATA(handle, config,
6025                                 struct fruit_config_data,
6026                                 return NULL);
6027
6028         req = tevent_req_create(mem_ctx, &state,
6029                                 struct fruit_offload_write_state);
6030         if (req == NULL) {
6031                 return NULL;
6032         }
6033         state->handle = handle;
6034         state->dst_fsp = dest_fsp;
6035
6036         switch (fsctl) {
6037         case FSCTL_SRV_COPYCHUNK:
6038         case FSCTL_SRV_COPYCHUNK_WRITE:
6039                 copyfile_enabled = config->copyfile_enabled;
6040                 break;
6041         default:
6042                 break;
6043         }
6044
6045         /*
6046          * Check if this a OS X copyfile style copychunk request with
6047          * a requested chunk count of 0 that was translated to a
6048          * offload_write_send VFS call overloading the parameters src_off
6049          * = dest_off = num = 0.
6050          */
6051         if (copyfile_enabled && num == 0 && src_off == 0 && dest_off == 0) {
6052                 status = vfs_offload_token_db_fetch_fsp(
6053                         fruit_offload_ctx, token, &src_fsp);
6054                 if (tevent_req_nterror(req, status)) {
6055                         return tevent_req_post(req, ev);
6056                 }
6057                 state->src_fsp = src_fsp;
6058
6059                 status = vfs_stat_fsp(src_fsp);
6060                 if (tevent_req_nterror(req, status)) {
6061                         return tevent_req_post(req, ev);
6062                 }
6063
6064                 to_copy = src_fsp->fsp_name->st.st_ex_size;
6065                 state->is_copyfile = true;
6066         }
6067
6068         subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle,
6069                                               mem_ctx,
6070                                               ev,
6071                                               fsctl,
6072                                               token,
6073                                               transfer_offset,
6074                                               dest_fsp,
6075                                               dest_off,
6076                                               to_copy);
6077         if (tevent_req_nomem(subreq, req)) {
6078                 return tevent_req_post(req, ev);
6079         }
6080
6081         tevent_req_set_callback(subreq, fruit_offload_write_done, req);
6082         return req;
6083 }
6084
6085 static void fruit_offload_write_done(struct tevent_req *subreq)
6086 {
6087         struct tevent_req *req = tevent_req_callback_data(
6088                 subreq, struct tevent_req);
6089         struct fruit_offload_write_state *state = tevent_req_data(
6090                 req, struct fruit_offload_write_state);
6091         NTSTATUS status;
6092         unsigned int num_streams = 0;
6093         struct stream_struct *streams = NULL;
6094         unsigned int i;
6095         struct smb_filename *src_fname_tmp = NULL;
6096         struct smb_filename *dst_fname_tmp = NULL;
6097
6098         status = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(state->handle,
6099                                               subreq,
6100                                               &state->copied);
6101         TALLOC_FREE(subreq);
6102         if (tevent_req_nterror(req, status)) {
6103                 return;
6104         }
6105
6106         if (!state->is_copyfile) {
6107                 tevent_req_done(req);
6108                 return;
6109         }
6110
6111         /*
6112          * Now copy all remaining streams. We know the share supports
6113          * streams, because we're in vfs_fruit. We don't do this async
6114          * because streams are few and small.
6115          */
6116         status = vfs_streaminfo(state->handle->conn, state->src_fsp,
6117                                 state->src_fsp->fsp_name,
6118                                 req, &num_streams, &streams);
6119         if (tevent_req_nterror(req, status)) {
6120                 return;
6121         }
6122
6123         if (num_streams == 1) {
6124                 /* There is always one stream, ::$DATA. */
6125                 tevent_req_done(req);
6126                 return;
6127         }
6128
6129         for (i = 0; i < num_streams; i++) {
6130                 DEBUG(10, ("%s: stream: '%s'/%zu\n",
6131                           __func__, streams[i].name, (size_t)streams[i].size));
6132
6133                 src_fname_tmp = synthetic_smb_fname(
6134                         req,
6135                         state->src_fsp->fsp_name->base_name,
6136                         streams[i].name,
6137                         NULL,
6138                         state->src_fsp->fsp_name->flags);
6139                 if (tevent_req_nomem(src_fname_tmp, req)) {
6140                         return;
6141                 }
6142
6143                 if (is_ntfs_default_stream_smb_fname(src_fname_tmp)) {
6144                         TALLOC_FREE(src_fname_tmp);
6145                         continue;
6146                 }
6147
6148                 dst_fname_tmp = synthetic_smb_fname(
6149                         req,
6150                         state->dst_fsp->fsp_name->base_name,
6151                         streams[i].name,
6152                         NULL,
6153                         state->dst_fsp->fsp_name->flags);
6154                 if (tevent_req_nomem(dst_fname_tmp, req)) {
6155                         TALLOC_FREE(src_fname_tmp);
6156                         return;
6157                 }
6158
6159                 status = copy_file(req,
6160                                    state->handle->conn,
6161                                    src_fname_tmp,
6162                                    dst_fname_tmp,
6163                                    OPENX_FILE_CREATE_IF_NOT_EXIST,
6164                                    0, false);
6165                 if (!NT_STATUS_IS_OK(status)) {
6166                         DEBUG(1, ("%s: copy %s to %s failed: %s\n", __func__,
6167                                   smb_fname_str_dbg(src_fname_tmp),
6168                                   smb_fname_str_dbg(dst_fname_tmp),
6169                                   nt_errstr(status)));
6170                         TALLOC_FREE(src_fname_tmp);
6171                         TALLOC_FREE(dst_fname_tmp);
6172                         tevent_req_nterror(req, status);
6173                         return;
6174                 }
6175
6176                 TALLOC_FREE(src_fname_tmp);
6177                 TALLOC_FREE(dst_fname_tmp);
6178         }
6179
6180         TALLOC_FREE(streams);
6181         TALLOC_FREE(src_fname_tmp);
6182         TALLOC_FREE(dst_fname_tmp);
6183         tevent_req_done(req);
6184 }
6185
6186 static NTSTATUS fruit_offload_write_recv(struct vfs_handle_struct *handle,
6187                                       struct tevent_req *req,
6188                                       off_t *copied)
6189 {
6190         struct fruit_offload_write_state *state = tevent_req_data(
6191                 req, struct fruit_offload_write_state);
6192         NTSTATUS status;
6193
6194         if (tevent_req_is_nterror(req, &status)) {
6195                 DEBUG(1, ("server side copy chunk failed: %s\n",
6196                           nt_errstr(status)));
6197                 *copied = 0;
6198                 tevent_req_received(req);
6199                 return status;
6200         }
6201
6202         *copied = state->copied;
6203         tevent_req_received(req);
6204
6205         return NT_STATUS_OK;
6206 }
6207
6208 static char *fruit_get_bandsize_line(char **lines, int numlines)
6209 {
6210         static regex_t re;
6211         static bool re_initialized = false;
6212         int i;
6213         int ret;
6214
6215         if (!re_initialized) {
6216                 ret = regcomp(&re, "^[[:blank:]]*<key>band-size</key>$", 0);
6217                 if (ret != 0) {
6218                         return NULL;
6219                 }
6220                 re_initialized = true;
6221         }
6222
6223         for (i = 0; i < numlines; i++) {
6224                 regmatch_t matches[1];
6225
6226                 ret = regexec(&re, lines[i], 1, matches, 0);
6227                 if (ret == 0) {
6228                         /*
6229                          * Check if the match was on the last line, sa we want
6230                          * the subsequent line.
6231                          */
6232                         if (i + 1 == numlines) {
6233                                 return NULL;
6234                         }
6235                         return lines[i + 1];
6236                 }
6237                 if (ret != REG_NOMATCH) {
6238                         return NULL;
6239                 }
6240         }
6241
6242         return NULL;
6243 }
6244
6245 static bool fruit_get_bandsize_from_line(char *line, size_t *_band_size)
6246 {
6247         static regex_t re;
6248         static bool re_initialized = false;
6249         regmatch_t matches[2];
6250         uint64_t band_size;
6251         int ret;
6252         bool ok;
6253
6254         if (!re_initialized) {
6255                 ret = regcomp(&re,
6256                               "^[[:blank:]]*"
6257                               "<integer>\\([[:digit:]]*\\)</integer>$",
6258                               0);
6259                 if (ret != 0) {
6260                         return false;
6261                 }
6262                 re_initialized = true;
6263         }
6264
6265         ret = regexec(&re, line, 2, matches, 0);
6266         if (ret != 0) {
6267                 DBG_ERR("regex failed [%s]\n", line);
6268                 return false;
6269         }
6270
6271         line[matches[1].rm_eo] = '\0';
6272
6273         ok = conv_str_u64(&line[matches[1].rm_so], &band_size);
6274         if (!ok) {
6275                 return false;
6276         }
6277         *_band_size = (size_t)band_size;
6278         return true;
6279 }
6280
6281 /*
6282  * This reads and parses an Info.plist from a TM sparsebundle looking for the
6283  * "band-size" key and value.
6284  */
6285 static bool fruit_get_bandsize(vfs_handle_struct *handle,
6286                                const char *dir,
6287                                size_t *band_size)
6288 {
6289 #define INFO_PLIST_MAX_SIZE 64*1024
6290         char *plist = NULL;
6291         struct smb_filename *smb_fname = NULL;
6292         files_struct *fsp = NULL;
6293         uint8_t *file_data = NULL;
6294         char **lines = NULL;
6295         char *band_size_line = NULL;
6296         size_t plist_file_size;
6297         ssize_t nread;
6298         int numlines;
6299         int ret;
6300         bool ok = false;
6301         NTSTATUS status;
6302
6303         plist = talloc_asprintf(talloc_tos(),
6304                                 "%s/%s/Info.plist",
6305                                 handle->conn->connectpath,
6306                                 dir);
6307         if (plist == NULL) {
6308                 ok = false;
6309                 goto out;
6310         }
6311
6312         smb_fname = synthetic_smb_fname(talloc_tos(), plist, NULL, NULL, 0);
6313         if (smb_fname == NULL) {
6314                 ok = false;
6315                 goto out;
6316         }
6317
6318         ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
6319         if (ret != 0) {
6320                 DBG_INFO("Ignoring Sparsebundle without Info.plist [%s]\n", dir);
6321                 ok = true;
6322                 goto out;
6323         }
6324
6325         plist_file_size = smb_fname->st.st_ex_size;
6326
6327         if (plist_file_size > INFO_PLIST_MAX_SIZE) {
6328                 DBG_INFO("%s is too large, ignoring\n", plist);
6329                 ok = true;
6330                 goto out;
6331         }
6332
6333         status = SMB_VFS_NEXT_CREATE_FILE(
6334                 handle,                         /* conn */
6335                 NULL,                           /* req */
6336                 0,                              /* root_dir_fid */
6337                 smb_fname,                      /* fname */
6338                 FILE_GENERIC_READ,              /* access_mask */
6339                 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
6340                 FILE_OPEN,                      /* create_disposition */
6341                 0,                              /* create_options */
6342                 0,                              /* file_attributes */
6343                 INTERNAL_OPEN_ONLY,             /* oplock_request */
6344                 NULL,                           /* lease */
6345                 0,                              /* allocation_size */
6346                 0,                              /* private_flags */
6347                 NULL,                           /* sd */
6348                 NULL,                           /* ea_list */
6349                 &fsp,                           /* result */
6350                 NULL,                           /* psbuf */
6351                 NULL, NULL);                    /* create context */
6352         if (!NT_STATUS_IS_OK(status)) {
6353                 DBG_INFO("Opening [%s] failed [%s]\n",
6354                          smb_fname_str_dbg(smb_fname), nt_errstr(status));
6355                 ok = false;
6356                 goto out;
6357         }
6358
6359         file_data = talloc_array(talloc_tos(), uint8_t, plist_file_size);
6360         if (file_data == NULL) {
6361                 ok = false;
6362                 goto out;
6363         }
6364
6365         nread = SMB_VFS_NEXT_PREAD(handle, fsp, file_data, plist_file_size, 0);
6366         if (nread != plist_file_size) {
6367                 DBG_ERR("Short read on [%s]: %zu/%zd\n",
6368                         fsp_str_dbg(fsp), nread, plist_file_size);
6369                 ok = false;
6370                 goto out;
6371
6372         }
6373
6374         status = close_file(NULL, fsp, NORMAL_CLOSE);
6375         fsp = NULL;
6376         if (!NT_STATUS_IS_OK(status)) {
6377                 DBG_ERR("close_file failed: %s\n", nt_errstr(status));
6378                 ok = false;
6379                 goto out;
6380         }
6381
6382         lines = file_lines_parse((char *)file_data,
6383                                  plist_file_size,
6384                                  &numlines,
6385                                  talloc_tos());
6386         if (lines == NULL) {
6387                 ok = false;
6388                 goto out;
6389         }
6390
6391         band_size_line = fruit_get_bandsize_line(lines, numlines);
6392         if (band_size_line == NULL) {
6393                 DBG_ERR("Didn't find band-size key in [%s]\n",
6394                         smb_fname_str_dbg(smb_fname));
6395                 ok = false;
6396                 goto out;
6397         }
6398
6399         ok = fruit_get_bandsize_from_line(band_size_line, band_size);
6400         if (!ok) {
6401                 DBG_ERR("fruit_get_bandsize_from_line failed\n");
6402                 goto out;
6403         }
6404
6405         DBG_DEBUG("Parsed band-size [%zu] for [%s]\n", *band_size, plist);
6406
6407 out:
6408         if (fsp != NULL) {
6409                 status = close_file(NULL, fsp, NORMAL_CLOSE);
6410                 if (!NT_STATUS_IS_OK(status)) {
6411                         DBG_ERR("close_file failed: %s\n", nt_errstr(status));
6412                 }
6413                 fsp = NULL;
6414         }
6415         TALLOC_FREE(plist);
6416         TALLOC_FREE(smb_fname);
6417         TALLOC_FREE(file_data);
6418         TALLOC_FREE(lines);
6419         return ok;
6420 }
6421
6422 struct fruit_disk_free_state {
6423         off_t total_size;
6424 };
6425
6426 static bool fruit_get_num_bands(vfs_handle_struct *handle,
6427                                 char *bundle,
6428                                 size_t *_nbands)
6429 {
6430         char *path = NULL;
6431         struct smb_filename *bands_dir = NULL;
6432         DIR *d = NULL;
6433         struct dirent *e = NULL;
6434         size_t nbands;
6435         int ret;
6436
6437         path = talloc_asprintf(talloc_tos(),
6438                                "%s/%s/bands",
6439                                handle->conn->connectpath,
6440                                bundle);
6441         if (path == NULL) {
6442                 return false;
6443         }
6444
6445         bands_dir = synthetic_smb_fname(talloc_tos(),
6446                                         path,
6447                                         NULL,
6448                                         NULL,
6449                                         0);
6450         TALLOC_FREE(path);
6451         if (bands_dir == NULL) {
6452                 return false;
6453         }
6454
6455         d = SMB_VFS_NEXT_OPENDIR(handle, bands_dir, NULL, 0);
6456         if (d == NULL) {
6457                 TALLOC_FREE(bands_dir);
6458                 return false;
6459         }
6460
6461         nbands = 0;
6462
6463         for (e = SMB_VFS_NEXT_READDIR(handle, d, NULL);
6464              e != NULL;
6465              e = SMB_VFS_NEXT_READDIR(handle, d, NULL))
6466         {
6467                 if (ISDOT(e->d_name) || ISDOTDOT(e->d_name)) {
6468                         continue;
6469                 }
6470                 nbands++;
6471         }
6472
6473         ret = SMB_VFS_NEXT_CLOSEDIR(handle, d);
6474         if (ret != 0) {
6475                 TALLOC_FREE(bands_dir);
6476                 return false;
6477         }
6478
6479         DBG_DEBUG("%zu bands in [%s]\n", nbands, smb_fname_str_dbg(bands_dir));
6480
6481         TALLOC_FREE(bands_dir);
6482
6483         *_nbands = nbands;
6484         return true;
6485 }
6486
6487 static bool fruit_tmsize_do_dirent(vfs_handle_struct *handle,
6488                                    struct fruit_disk_free_state *state,
6489                                    struct dirent *e)
6490 {
6491         bool ok;
6492         char *p = NULL;
6493         size_t sparsebundle_strlen = strlen("sparsebundle");
6494         size_t bandsize = 0;
6495         size_t nbands;
6496         off_t tm_size;
6497
6498         p = strstr(e->d_name, "sparsebundle");
6499         if (p == NULL) {
6500                 return true;
6501         }
6502
6503         if (p[sparsebundle_strlen] != '\0') {
6504                 return true;
6505         }
6506
6507         DBG_DEBUG("Processing sparsebundle [%s]\n", e->d_name);
6508
6509         ok = fruit_get_bandsize(handle, e->d_name, &bandsize);
6510         if (!ok) {
6511                 /*
6512                  * Beware of race conditions: this may be an uninitialized
6513                  * Info.plist that a client is just creating. We don't want let
6514                  * this to trigger complete failure.
6515                  */
6516                 DBG_ERR("Processing sparsebundle [%s] failed\n", e->d_name);
6517                 return true;
6518         }
6519
6520         ok = fruit_get_num_bands(handle, e->d_name, &nbands);
6521         if (!ok) {
6522                 /*
6523                  * Beware of race conditions: this may be a backup sparsebundle
6524                  * in an early stage lacking a bands subdirectory. We don't want
6525                  * let this to trigger complete failure.
6526                  */
6527                 DBG_ERR("Processing sparsebundle [%s] failed\n", e->d_name);
6528                 return true;
6529         }
6530
6531         tm_size = bandsize * nbands;
6532         if (tm_size > UINT64_MAX) {
6533                 DBG_ERR("tmsize overflow: bandsize [%zu] nbands [%zu]\n",
6534                         bandsize, nbands);
6535                 return false;
6536         }
6537
6538         if (state->total_size + tm_size < state->total_size) {
6539                 DBG_ERR("tmsize overflow: bandsize [%zu] nbands [%zu]\n",
6540                         bandsize, nbands);
6541                 return false;
6542         }
6543
6544         state->total_size += tm_size;
6545
6546         DBG_DEBUG("[%s] tm_size [%jd] total_size [%jd]\n",
6547                   e->d_name, (intmax_t)tm_size, (intmax_t)state->total_size);
6548
6549         return true;
6550 }
6551
6552 /**
6553  * Calculate used size of a TimeMachine volume
6554  *
6555  * This assumes that the volume is used only for TimeMachine.
6556  *
6557  * - readdir(basedir of share), then
6558  * - for every element that matches regex "^\(.*\)\.sparsebundle$" :
6559  * - parse "\1.sparsebundle/Info.plist" and read the band-size XML key
6560  * - count band files in "\1.sparsebundle/bands/"
6561  * - calculate used size of all bands: band_count * band_size
6562  **/
6563 static uint64_t fruit_disk_free(vfs_handle_struct *handle,
6564                                 const struct smb_filename *smb_fname,
6565                                 uint64_t *_bsize,
6566                                 uint64_t *_dfree,
6567                                 uint64_t *_dsize)
6568 {
6569         struct fruit_config_data *config = NULL;
6570         struct fruit_disk_free_state state = {0};
6571         DIR *d = NULL;
6572         struct dirent *e = NULL;
6573         uint64_t dfree;
6574         uint64_t dsize;
6575         int ret;
6576         bool ok;
6577
6578         SMB_VFS_HANDLE_GET_DATA(handle, config,
6579                                 struct fruit_config_data,
6580                                 return UINT64_MAX);
6581
6582         if (!config->time_machine ||
6583             config->time_machine_max_size == 0)
6584         {
6585                 return SMB_VFS_NEXT_DISK_FREE(handle,
6586                                               smb_fname,
6587                                               _bsize,
6588                                               _dfree,
6589                                               _dsize);
6590         }
6591
6592         d = SMB_VFS_NEXT_OPENDIR(handle, smb_fname, NULL, 0);
6593         if (d == NULL) {
6594                 return UINT64_MAX;
6595         }
6596
6597         for (e = SMB_VFS_NEXT_READDIR(handle, d, NULL);
6598              e != NULL;
6599              e = SMB_VFS_NEXT_READDIR(handle, d, NULL))
6600         {
6601                 ok = fruit_tmsize_do_dirent(handle, &state, e);
6602                 if (!ok) {
6603                         SMB_VFS_NEXT_CLOSEDIR(handle, d);
6604                         return UINT64_MAX;
6605                 }
6606         }
6607
6608         ret = SMB_VFS_NEXT_CLOSEDIR(handle, d);
6609         if (ret != 0) {
6610                 return UINT64_MAX;
6611         }
6612
6613         dsize = config->time_machine_max_size / 512;
6614         dfree = dsize - (state.total_size / 512);
6615         if (dfree > dsize) {
6616                 dfree = 0;
6617         }
6618
6619         *_bsize = 512;
6620         *_dsize = dsize;
6621         *_dfree = dfree;
6622         return dfree / 2;
6623 }
6624
6625 static struct vfs_fn_pointers vfs_fruit_fns = {
6626         .connect_fn = fruit_connect,
6627         .disk_free_fn = fruit_disk_free,
6628
6629         /* File operations */
6630         .chmod_fn = fruit_chmod,
6631         .chown_fn = fruit_chown,
6632         .unlink_fn = fruit_unlink,
6633         .rename_fn = fruit_rename,
6634         .rmdir_fn = fruit_rmdir,
6635         .open_fn = fruit_open,
6636         .pread_fn = fruit_pread,
6637         .pwrite_fn = fruit_pwrite,
6638         .pread_send_fn = fruit_pread_send,
6639         .pread_recv_fn = fruit_pread_recv,
6640         .pwrite_send_fn = fruit_pwrite_send,
6641         .pwrite_recv_fn = fruit_pwrite_recv,
6642         .stat_fn = fruit_stat,
6643         .lstat_fn = fruit_lstat,
6644         .fstat_fn = fruit_fstat,
6645         .streaminfo_fn = fruit_streaminfo,
6646         .ntimes_fn = fruit_ntimes,
6647         .ftruncate_fn = fruit_ftruncate,
6648         .fallocate_fn = fruit_fallocate,
6649         .create_file_fn = fruit_create_file,
6650         .readdir_attr_fn = fruit_readdir_attr,
6651         .offload_read_send_fn = fruit_offload_read_send,
6652         .offload_read_recv_fn = fruit_offload_read_recv,
6653         .offload_write_send_fn = fruit_offload_write_send,
6654         .offload_write_recv_fn = fruit_offload_write_recv,
6655
6656         /* NT ACL operations */
6657         .fget_nt_acl_fn = fruit_fget_nt_acl,
6658         .fset_nt_acl_fn = fruit_fset_nt_acl,
6659 };
6660
6661 static_decl_vfs;
6662 NTSTATUS vfs_fruit_init(TALLOC_CTX *ctx)
6663 {
6664         NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fruit",
6665                                         &vfs_fruit_fns);
6666         if (!NT_STATUS_IS_OK(ret)) {
6667                 return ret;
6668         }
6669
6670         vfs_fruit_debug_level = debug_add_class("fruit");
6671         if (vfs_fruit_debug_level == -1) {
6672                 vfs_fruit_debug_level = DBGC_VFS;
6673                 DEBUG(0, ("%s: Couldn't register custom debugging class!\n",
6674                           "vfs_fruit_init"));
6675         } else {
6676                 DEBUG(10, ("%s: Debug class number of '%s': %d\n",
6677                            "vfs_fruit_init","fruit",vfs_fruit_debug_level));
6678         }
6679
6680         return ret;
6681 }