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