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