libatalk/vfs/vfs.c

   1 /*
   2     Copyright (c) 2004 Didier Gautheron
   3     Copyright (c) 2009 Frank Lahm
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif /* HAVE_CONFIG_H */
  23
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <unistd.h>
  27 #include <string.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <libgen.h>
  31
  32 #include <atalk/afp.h>
  33 #include <atalk/adouble.h>
  34 #include <atalk/ea.h>
  35 #include <atalk/acl.h>
  36 #include <atalk/logger.h>
  37 #include <atalk/util.h>
  38 #include <atalk/volume.h>
  39 #include <atalk/vfs.h>
  40 #include <atalk/directory.h>
  41 #include <atalk/unix.h>
  42 #include <atalk/errchk.h>
  43 #include <atalk/bstrlib.h>
  44 #include <atalk/bstradd.h>
  45 #include <atalk/compat.h>
  46
  47 struct perm {
  48     uid_t uid;
  49     gid_t gid;
  50 };
  51
  52 typedef int (*rf_loop)(struct dirent *, char *, void *, int , mode_t );
  53
  54 /* ----------------------------- */
  55 static int
  56 for_each_adouble(const char *from, const char *name, rf_loop fn, void *data, int flag, mode_t v_umask)
  57 {
  58     char            buf[ MAXPATHLEN + 1];
  59     char            *m;
  60     DIR             *dp;
  61     struct dirent   *de;
  62     int             ret;
  63
  64
  65     if (NULL == ( dp = opendir( name)) ) {
  66         if (!flag) {
  67             LOG(log_error, logtype_afpd, "%s: opendir %s: %s", from, fullpathname(name),strerror(errno) );
  68             return -1;
  69         }
  70         return 0;
  71     }
  72     strlcpy( buf, name, sizeof(buf));
  73     strlcat( buf, "/", sizeof(buf) );
  74     m = strchr( buf, '\0' );
  75     ret = 0;
  76     while ((de = readdir(dp))) {
  77         if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
  78                 continue;
  79         }
  80
  81         strlcat(buf, de->d_name, sizeof(buf));
  82         if (fn && (ret = fn(de, buf, data, flag, v_umask))) {
  83            closedir(dp);
  84            return ret;
  85         }
  86         *m = 0;
  87     }
  88     closedir(dp);
  89     return ret;
  90 }
  91
  92 /*******************************************************************************
  93  * classic adouble format
  94  *******************************************************************************/
  95
  96 static int netatalk_name(const char *name)
  97 {
  98     return strcasecmp(name,".AppleDouble") &&
  99         strcasecmp(name,".AppleDB") &&
 100         strcasecmp(name,".AppleDesktop");
 101 }
 102
 103 static int validupath_adouble(VFS_FUNC_ARGS_VALIDUPATH)
 104 {
 105     if (name[0] != '.')
 106         return 1;
 107
 108     if (!(vol->v_flags & AFPVOL_USEDOTS))
 109         return 0;
 110
 111     return netatalk_name(name) && strcasecmp(name,".Parent");
 112 }
 113
 114 /* ----------------- */
 115 static int RF_chown_adouble(VFS_FUNC_ARGS_CHOWN)
 116 {
 117     struct stat st;
 118     const char *ad_p;
 119
 120     ad_p = vol->ad_path(path, ADFLAGS_HF );
 121
 122     if ( stat( ad_p, &st ) < 0 )
 123         return 0; /* ignore */
 124
 125     return chown( ad_p, uid, gid );
 126 }
 127
 128 /* ----------------- */
 129 static int RF_renamedir_adouble(VFS_FUNC_ARGS_RENAMEDIR)
 130 {
 131     return 0;
 132 }
 133
 134 /* ----------------- */
 135 static int deletecurdir_adouble_loop(struct dirent *de, char *name, void *data _U_, int flag _U_, mode_t v_umask)
 136 {
 137     struct stat st;
 138     int         err;
 139
 140     /* bail if the file exists in the current directory.
 141      * note: this will not fail with dangling symlinks */
 142
 143     if (lstat(de->d_name, &st) == 0)
 144         return AFPERR_DIRNEMPT;
 145
 146     if ((err = netatalk_unlink(name)))
 147         return err;
 148
 149     return 0;
 150 }
 151
 152 static int RF_deletecurdir_adouble(VFS_FUNC_ARGS_DELETECURDIR)
 153 {
 154     int err;
 155
 156     /* delete stray .AppleDouble files. this happens to get .Parent files
 157        as well. */
 158     if ((err = for_each_adouble("deletecurdir", ".AppleDouble", deletecurdir_adouble_loop, NULL, 1, vol->v_umask)))
 159         return err;
 160     return netatalk_rmdir(-1, ".AppleDouble" );
 161 }
 162
 163 /* ----------------- */
 164 static int adouble_setfilmode(const char * name, mode_t mode, struct stat *st, mode_t v_umask)
 165 {
 166     return setfilmode(name, ad_hf_mode(mode), st, v_umask);
 167 }
 168
 169 static int RF_setfilmode_adouble(VFS_FUNC_ARGS_SETFILEMODE)
 170 {
 171     return adouble_setfilmode(vol->ad_path(name, ADFLAGS_HF ), mode, st, vol->v_umask);
 172 }
 173
 174 /* ----------------- */
 175 static int RF_setdirunixmode_adouble(VFS_FUNC_ARGS_SETDIRUNIXMODE)
 176 {
 177     const char *adouble = vol->ad_path(name, ADFLAGS_DIR );
 178     int  dropbox = vol->v_flags;
 179
 180     if (dir_rx_set(mode)) {
 181         if (stickydirmode(ad_dir(adouble), DIRBITS | mode, dropbox, vol->v_umask) < 0 )
 182             return -1;
 183     }
 184
 185     if (adouble_setfilmode(vol->ad_path(name, ADFLAGS_DIR ), mode, st, vol->v_umask) < 0)
 186         return -1;
 187
 188     if (!dir_rx_set(mode)) {
 189         if (stickydirmode(ad_dir(adouble), DIRBITS | mode, dropbox, vol->v_umask) < 0 )
 190             return  -1 ;
 191     }
 192     return 0;
 193 }
 194
 195 /* ----------------- */
 196 static int setdirmode_adouble_loop(struct dirent *de _U_, char *name, void *data, int flag, mode_t v_umask)
 197 {
 198     mode_t hf_mode = *(mode_t *)data;
 199     struct stat st;
 200
 201     if ( stat( name, &st ) < 0 ) {
 202         if (flag)
 203             return 0;
 204         LOG(log_error, logtype_afpd, "setdirmode: stat %s: %s", name, strerror(errno) );
 205     }
 206     else if (!S_ISDIR(st.st_mode)) {
 207         if (setfilmode(name, hf_mode , &st, v_umask) < 0) {
 208                /* FIXME what do we do then? */
 209         }
 210     }
 211     return 0;
 212 }
 213
 214 static int RF_setdirmode_adouble(VFS_FUNC_ARGS_SETDIRMODE)
 215 {
 216     int   dropbox = vol->v_flags;
 217     mode_t hf_mode = ad_hf_mode(mode);
 218     const char  *adouble = vol->ad_path(name, ADFLAGS_DIR );
 219     const char  *adouble_p = ad_dir(adouble);
 220
 221     if (dir_rx_set(mode)) {
 222         if (stickydirmode(ad_dir(adouble), DIRBITS | mode, dropbox, vol->v_umask) < 0)
 223             return -1;
 224     }
 225
 226     if (for_each_adouble("setdirmode", adouble_p, setdirmode_adouble_loop, &hf_mode, 0, vol->v_umask))
 227         return -1;
 228
 229     if (!dir_rx_set(mode)) {
 230         if (stickydirmode(ad_dir(adouble), DIRBITS | mode, dropbox, vol->v_umask) < 0)
 231             return  -1 ;
 232     }
 233     return 0;
 234 }
 235
 236 /* ----------------- */
 237 static int setdirowner_adouble_loop(struct dirent *de _U_, char *name, void *data, int flag _U_, mode_t v_umask _U_)
 238 {
 239     struct perm   *owner  = data;
 240
 241     if ( chown( name, owner->uid, owner->gid ) < 0 && errno != EPERM ) {
 242          LOG(log_debug, logtype_afpd, "setdirowner: chown %d/%d %s: %s",
 243                 owner->uid, owner->gid, fullpathname(name), strerror(errno) );
 244          /* return ( -1 ); Sometimes this is okay */
 245     }
 246     return 0;
 247 }
 248
 249 static int RF_setdirowner_adouble(VFS_FUNC_ARGS_SETDIROWNER)
 250 {
 251     char          *adouble_p;
 252     struct stat   st;
 253     struct perm   owner;
 254
 255     owner.uid = uid;
 256     owner.gid = gid;
 257
 258     adouble_p = ad_dir(vol->ad_path(name, ADFLAGS_DIR ));
 259
 260     if (for_each_adouble("setdirowner", adouble_p, setdirowner_adouble_loop, &owner, 0, vol->v_umask))
 261         return -1;
 262
 263     /*
 264      * We cheat: we know that chown doesn't do anything.
 265      */
 266     if ( stat( ".AppleDouble", &st ) < 0) {
 267         LOG(log_error, logtype_afpd, "setdirowner: stat %s: %s", fullpathname(".AppleDouble"), strerror(errno) );
 268         return -1;
 269     }
 270     if ( gid && gid != st.st_gid && chown( ".AppleDouble", uid, gid ) < 0 && errno != EPERM ) {
 271         LOG(log_debug, logtype_afpd, "setdirowner: chown %d/%d %s: %s",
 272             uid, gid,fullpathname(".AppleDouble"), strerror(errno) );
 273         /* return ( -1 ); Sometimes this is okay */
 274     }
 275     return 0;
 276 }
 277
 278 /* ----------------- */
 279 static int RF_deletefile_adouble(VFS_FUNC_ARGS_DELETEFILE)
 280 {
 281         return netatalk_unlinkat(dirfd, vol->ad_path(file, ADFLAGS_HF));
 282 }
 283
 284 /* ----------------- */
 285 static int RF_renamefile_adouble(VFS_FUNC_ARGS_RENAMEFILE)
 286 {
 287     char  adsrc[ MAXPATHLEN + 1];
 288     int   err = 0;
 289
 290     strcpy( adsrc, vol->ad_path(src, 0 ));
 291     if (unix_rename(dirfd, adsrc, -1, vol->ad_path(dst, 0 )) < 0) {
 292         struct stat st;
 293
 294         err = errno;
 295         if (errno == ENOENT) {
 296                 struct adouble    ad;
 297
 298             if (lstatat(dirfd, adsrc, &st)) /* source has no ressource fork, */
 299                 return 0;
 300
 301             /* We are here  because :
 302              * -there's no dest folder.
 303              * -there's no .AppleDouble in the dest folder.
 304              * if we use the struct adouble passed in parameter it will not
 305              * create .AppleDouble if the file is already opened, so we
 306              * use a diff one, it's not a pb,ie it's not the same file, yet.
 307              */
 308             ad_init(&ad, vol);
 309             if (ad_open(&ad, dst, ADFLAGS_HF | ADFLAGS_RDWR | ADFLAGS_CREATE, 0666) == 0) {
 310                 ad_close(&ad, ADFLAGS_HF);
 311                 if (!unix_rename(dirfd, adsrc, -1, vol->ad_path(dst, 0 )) )
 312                    err = 0;
 313                 else
 314                    err = errno;
 315             }
 316             else { /* it's something else, bail out */
 317                     err = errno;
 318                 }
 319             }
 320         }
 321         if (err) {
 322                 errno = err;
 323                 return -1;
 324         }
 325         return 0;
 326 }
 327
 328 static int RF_copyfile_adouble(VFS_FUNC_ARGS_COPYFILE)
 329 /* const struct vol *vol, int sfd, const char *src, const char *dst */
 330 {
 331     return 0;
 332 #if 0
 333     EC_INIT;
 334     bstring s = NULL, d = NULL;
 335     char *dup1 = NULL;
 336     char *dup2 = NULL;
 337     char *dup3 = NULL;
 338     char *dup4 = NULL;
 339     const char *name = NULL;
 340     const char *dir = NULL;
 341
 342     struct stat st;
 343     EC_ZERO(stat(dst, &st));
 344
 345     if (S_ISDIR(st.st_mode)) {
 346         /* build src path to AppleDouble file*/
 347         EC_NULL(s = bfromcstr(src));
 348         EC_ZERO(bcatcstr(s, "/.AppleDouble/.Parent"));
 349
 350         /* build dst path to AppleDouble file*/
 351         EC_NULL(d = bfromcstr(dst));
 352         EC_ZERO(bcatcstr(d, "/.AppleDouble/.Parent"));
 353     } else {
 354         /* get basename */
 355
 356         /* build src path to AppleDouble file*/
 357         EC_NULL(dup1 = strdup(src));
 358         EC_NULL(name = basename(strdup(dup1)));
 359
 360         EC_NULL(dup2 = strdup(src));
 361         EC_NULL(dir = dirname(dup2));
 362         EC_NULL(s = bfromcstr(dir));
 363         EC_ZERO(bcatcstr(s, "/.AppleDouble/"));
 364         EC_ZERO(bcatcstr(s, name));
 365
 366         /* build dst path to AppleDouble file*/
 367         EC_NULL(dup4 = strdup(dst));
 368         EC_NULL(name = basename(strdup(dup4)));
 369
 370         EC_NULL(dup3 = strdup(dst));
 371         EC_NULL(dir = dirname(dup3));
 372         EC_NULL(d = bfromcstr(dir));
 373         EC_ZERO(bcatcstr(d, "/.AppleDouble/"));
 374         EC_ZERO(bcatcstr(d, name));
 375     }
 376
 377     EC_ZERO(copy_file(sfd, cfrombstr(s), cfrombstr(d), 0666));
 378
 379 EC_CLEANUP:
 380     bdestroy(s);
 381     bdestroy(d);
 382     if (dup1) free(dup1);
 383     if (dup2) free(dup2);
 384     if (dup3) free(dup3);
 385     if (dup4) free(dup4);
 386
 387     EC_EXIT;
 388 #endif
 389 }
 390
 391 #ifdef HAVE_SOLARIS_ACLS
 392 static int RF_solaris_acl(VFS_FUNC_ARGS_ACL)
 393 {
 394     static char buf[ MAXPATHLEN + 1];
 395     struct stat st;
 396     int len;
 397
 398     if ((stat(path, &st)) != 0)
 399         return -1;
 400     if (S_ISDIR(st.st_mode)) {
 401         len = snprintf(buf, MAXPATHLEN, "%s/.AppleDouble",path);
 402         if (len < 0 || len >=  MAXPATHLEN)
 403             return -1;
 404         /* set acl on .AppleDouble dir first */
 405         if ((acl(buf, cmd, count, aces)) != 0)
 406             return -1;
 407         /* now set ACL on ressource fork */
 408         if ((acl(vol->ad_path(path, ADFLAGS_DIR), cmd, count, aces)) != 0)
 409             return -1;
 410     } else
 411         /* set ACL on ressource fork */
 412         if ((acl(vol->ad_path(path, ADFLAGS_HF), cmd, count, aces)) != 0)
 413             return -1;
 414
 415     return 0;
 416 }
 417
 418 static int RF_solaris_remove_acl(VFS_FUNC_ARGS_REMOVE_ACL)
 419 {
 420     int ret;
 421     static char buf[ MAXPATHLEN + 1];
 422     int len;
 423
 424     if (dir) {
 425         len = snprintf(buf, MAXPATHLEN, "%s/.AppleDouble",path);
 426         if (len < 0 || len >=  MAXPATHLEN)
 427             return AFPERR_MISC;
 428         /* remove ACL from .AppleDouble/.Parent first */
 429         if ((ret = remove_acl_vfs(vol->ad_path(path, ADFLAGS_DIR))) != AFP_OK)
 430             return ret;
 431         /* now remove from .AppleDouble dir */
 432         if ((ret = remove_acl_vfs(buf)) != AFP_OK)
 433             return ret;
 434     } else
 435         /* remove ACL from ressource fork */
 436         if ((ret = remove_acl_vfs(vol->ad_path(path, ADFLAGS_HF))) != AFP_OK)
 437             return ret;
 438
 439     return AFP_OK;
 440 }
 441 #endif
 442
 443 #ifdef HAVE_POSIX_ACLS
 444 static int RF_posix_acl(VFS_FUNC_ARGS_ACL)
 445 {
 446     EC_INIT;
 447     static char buf[ MAXPATHLEN + 1];
 448     struct stat st;
 449     int len;
 450
 451     if (S_ISDIR(st.st_mode)) {
 452         len = snprintf(buf, MAXPATHLEN, "%s/.AppleDouble",path);
 453         if (len < 0 || len >=  MAXPATHLEN)
 454             EC_FAIL;
 455         /* set acl on .AppleDouble dir first */
 456         EC_ZERO_LOG(acl_set_file(buf, type, acl));
 457
 458         if (type == ACL_TYPE_ACCESS)
 459             /* set ACL on ressource fork (".Parent") too */
 460             EC_ZERO_LOG(acl_set_file(vol->ad_path(path, ADFLAGS_DIR), type, acl));
 461     } else {
 462         /* set ACL on ressource fork */
 463         EC_ZERO_LOG(acl_set_file(vol->ad_path(path, ADFLAGS_HF), type, acl));
 464     }
 465
 466 EC_CLEANUP:
 467     if (ret != 0)
 468         return AFPERR_MISC;
 469     return AFP_OK;
 470 }
 471
 472 static int RF_posix_remove_acl(VFS_FUNC_ARGS_REMOVE_ACL)
 473 {
 474     EC_INIT;
 475     static char buf[ MAXPATHLEN + 1];
 476     int len;
 477
 478     if (dir) {
 479         len = snprintf(buf, MAXPATHLEN, "%s/.AppleDouble",path);
 480         if (len < 0 || len >=  MAXPATHLEN)
 481             return AFPERR_MISC;
 482         /* remove ACL from .AppleDouble/.Parent first */
 483         EC_ZERO_LOG_ERR(remove_acl_vfs(vol->ad_path(path, ADFLAGS_DIR)), AFPERR_MISC);
 484
 485         /* now remove from .AppleDouble dir */
 486         EC_ZERO_LOG_ERR(remove_acl_vfs(buf), AFPERR_MISC);
 487     } else {
 488         /* remove ACL from ressource fork */
 489         EC_ZERO_LOG_ERR(remove_acl_vfs(vol->ad_path(path, ADFLAGS_HF)), AFPERR_MISC);
 490     }
 491
 492 EC_CLEANUP:
 493     EC_EXIT;
 494 }
 495 #endif
 496
 497 /*************************************************************************
 498  * EA adouble format
 499  ************************************************************************/
 500 static int validupath_ea(VFS_FUNC_ARGS_VALIDUPATH)
 501 {
 502     if (name[0] != '.')
 503         return 1;
 504
 505     if (!(vol->v_flags & AFPVOL_USEDOTS))
 506         return 0;
 507
 508 #ifndef HAVE_EAFD
 509     if (name[1] == '_')
 510         return 0;
 511 #endif
 512     return netatalk_name(name) && strcasecmp(name,".Parent");
 513 }
 514
 515 /* ----------------- */
 516 static int RF_chown_ea(VFS_FUNC_ARGS_CHOWN)
 517 {
 518 #ifndef HAVE_EAFD
 519     return chown(vol->ad_path(path, ADFLAGS_HF ), uid, gid);
 520 #endif
 521     return 0;
 522 }
 523
 524 /* ---------------- */
 525 static int RF_renamedir_ea(VFS_FUNC_ARGS_RENAMEDIR)
 526 {
 527     return 0;
 528 }
 529
 530 /* Returns 1 if the entry is NOT an ._ file */
 531 static int deletecurdir_ea_osx_chkifempty_loop(struct dirent *de, char *name, void *data _U_, int flag _U_, mode_t v_umask _U_)
 532 {
 533     if (de->d_name[0] != '.' || de->d_name[0] == '_')
 534         return 1;
 535
 536     return 0;
 537 }
 538
 539 static int deletecurdir_ea_osx_loop(struct dirent *de, char *name, void *data _U_, int flag _U_, mode_t v_umask _U_)
 540 {
 541     int ret;
 542
 543     if ((ret = netatalk_unlink(name)) != 0)
 544         return ret;
 545
 546     return 0;
 547 }
 548
 549 /* ---------------- */
 550 static int RF_deletecurdir_ea(VFS_FUNC_ARGS_DELETECURDIR)
 551 {
 552 #ifndef HAVE_EAFD
 553     int err;
 554     /* delete stray ._AppleDouble files */
 555
 556     /* first check if there's really no other file besides files starting with ._ */
 557     if ((err = for_each_adouble("deletecurdir_ea_osx", ".",
 558                                 deletecurdir_ea_osx_chkifempty_loop,
 559                                 NULL, 0, 0)) != 0) {
 560         if (err == 1)
 561             return AFPERR_DIRNEMPT;
 562         return AFPERR_MISC;
 563     }
 564
 565     /* Now delete orphaned ._ files */
 566     if ((err = for_each_adouble("deletecurdir_ea_osx", ".",
 567                                 deletecurdir_ea_osx_loop,
 568                                 NULL, 0, 0)) != 0)
 569         return err;
 570
 571 #endif
 572     return 0;
 573 }
 574
 575 /* ---------------- */
 576 static int RF_setdirunixmode_ea(VFS_FUNC_ARGS_SETDIRUNIXMODE)
 577 {
 578 #ifndef HAVE_EAFD
 579 #endif
 580     return 0;
 581 }
 582
 583 static int RF_setfilmode_ea(VFS_FUNC_ARGS_SETFILEMODE)
 584 {
 585 #ifndef HAVE_EAFD
 586     return adouble_setfilmode(vol->ad_path(name, ADFLAGS_HF ), mode, st, vol->v_umask);
 587 #endif
 588     return 0;
 589 }
 590
 591 /* ---------------- */
 592 static int RF_setdirmode_ea(VFS_FUNC_ARGS_SETDIRMODE)
 593 {
 594 #ifndef HAVE_EAFD
 595 #endif
 596     return 0;
 597 }
 598
 599 /* ---------------- */
 600 static int RF_setdirowner_ea(VFS_FUNC_ARGS_SETDIROWNER)
 601 {
 602 #ifndef HAVE_EAFD
 603 #endif
 604         return 0;
 605 }
 606
 607 static int RF_deletefile_ea(VFS_FUNC_ARGS_DELETEFILE)
 608 {
 609 #ifndef HAVE_EAFD
 610         return netatalk_unlinkat(dirfd, vol->ad_path(file, ADFLAGS_HF));
 611 #endif
 612     return 0;
 613 }
 614 static int RF_copyfile_ea(VFS_FUNC_ARGS_COPYFILE)
 615 {
 616     return 0;
 617 #if 0
 618     EC_INIT;
 619
 620     /* copy meta EA */
 621     if (copy_ea(AD_EA_META, sfd, src, dst, 0666) != 0)
 622         return AFPERR_MISC;
 623
 624     /* copy reso */
 625 #ifdef HAVE_EAFD
 626     int sfile = -1, dfile = -1, sea = -1, dea = -1;
 627
 628     if ((sfile = openat(sfd, src, O_RDONLY)) == -1) {
 629         ret = AFPERR_MISC;
 630         goto copyresoerr;
 631     }
 632
 633     if ((dfile = open(dts, O_WRONLY)) == -1) {
 634         ret = AFPERR_MISC;
 635         goto copyresoerr;
 636     }
 637
 638     if ((sea = openat(sfile, AD_EA_RESO, O_RDONLY | O_XATTR)) == -1) {
 639         ret = AFPERR_MISC;
 640         goto copyresoerr;
 641     }
 642
 643     if ((dea = openat(dfile, AD_EA_RESO, O_RDWR | O_CREAT | O_XATTR)) == -1) {
 644         ret = AFPERR_MISC;
 645         goto copyresoerr;
 646     }
 647
 648     ret = copy_file_fd(sea, dea);
 649
 650 copyresoerr:
 651     if (sfile != -1) close(sfile);
 652     if (dfile != -1) close(dfile);
 653     if (sea != -1) close(sea);
 654     if (dea != -1) close(dea);
 655     if (ret != 0)
 656         return ret;
 657
 658 EC_CLEANUP:
 659 #else
 660     bstring s = NULL, d = NULL;
 661     char *dup1 = NULL;
 662     char *dup2 = NULL;
 663     char *dup3 = NULL;
 664     char *dup4 = NULL;
 665     const char *name = NULL;
 666     const char *dir = NULL;
 667
 668     /* get basename */
 669
 670     /* build src path to ._ file*/
 671     EC_NULL(dup1 = strdup(src));
 672     EC_NULL(name = basename(strdup(dup1)));
 673
 674     EC_NULL(dup2 = strdup(src));
 675     EC_NULL(dir = dirname(dup2));
 676     EC_NULL(s = bfromcstr(dir));
 677     EC_ZERO(bcatcstr(s, "/._"));
 678     EC_ZERO(bcatcstr(s, name));
 679
 680     /* build dst path to ._file*/
 681     EC_NULL(dup4 = strdup(dst));
 682     EC_NULL(name = basename(strdup(dup4)));
 683
 684     EC_NULL(dup3 = strdup(dst));
 685     EC_NULL(dir = dirname(dup3));
 686     EC_NULL(d = bfromcstr(dir));
 687     EC_ZERO(bcatcstr(d, "/._"));
 688     EC_ZERO(bcatcstr(d, name));
 689
 690     EC_ZERO(copy_file(sfd, cfrombstr(s), cfrombstr(d), 0666));
 691
 692 EC_CLEANUP:
 693     bdestroy(s);
 694     bdestroy(d);
 695     free(dup1);
 696     free(dup2);
 697     free(dup3);
 698     free(dup4);
 699 #endif
 700 out:
 701     EC_EXIT;
 702 #endif
 703 }
 704
 705 /* ---------------- */
 706 static int RF_renamefile_ea(VFS_FUNC_ARGS_RENAMEFILE)
 707 {
 708 #ifndef HAVE_EAFD
 709     char  adsrc[ MAXPATHLEN + 1];
 710     int   err = 0;
 711
 712     strcpy( adsrc, vol->ad_path(src, 0 ));
 713
 714     if (unix_rename(dirfd, adsrc, -1, vol->ad_path(dst, 0 )) < 0) {
 715         struct stat st;
 716
 717         err = errno;
 718         if (errno == ENOENT && lstatat(dirfd, adsrc, &st)) /* source has no ressource fork, */
 719             return 0;
 720         errno = err;
 721         return -1;
 722     }
 723     return 0;
 724 #endif
 725     return 0;
 726 }
 727
 728 /********************************************************************************************
 729  * VFS chaining
 730  ********************************************************************************************/
 731
 732 /*
 733  * Up until we really start stacking many VFS modules on top of one another or use
 734  * dynamic module loading like we do for UAMs, up until then we just stack VFS modules
 735  * via an fixed size array.
 736  * All VFS funcs must return AFP_ERR codes. When a func in the chain returns an error
 737  * this error code will be returned to the caller, BUT the chain in followed and all
 738  * following funcs are called in order to give them a chance.
 739  */
 740
 741 /*
 742  * Define most VFS funcs with macros as they all do the same.
 743  * Only "ad_path" and "validupath" will NOT do stacking and only
 744  * call the func from the first module.
 745  */
 746
 747 #define VFS_MFUNC(name, args, vars) \
 748     static int vfs_ ## name(args) \
 749     { \
 750         int i = 0, ret = AFP_OK, err; \
 751         while (vol->vfs_modules[i]) { \
 752             if (vol->vfs_modules[i]->vfs_ ## name) { \
 753                 err = vol->vfs_modules[i]->vfs_ ## name (vars); \
 754                 if ((ret == AFP_OK) && (err != AFP_OK)) \
 755                     ret = err; \
 756             } \
 757             i ++; \
 758         } \
 759         return ret; \
 760     }
 761
 762 VFS_MFUNC(chown, VFS_FUNC_ARGS_CHOWN, VFS_FUNC_VARS_CHOWN)
 763 VFS_MFUNC(renamedir, VFS_FUNC_ARGS_RENAMEDIR, VFS_FUNC_VARS_RENAMEDIR)
 764 VFS_MFUNC(deletecurdir, VFS_FUNC_ARGS_DELETECURDIR, VFS_FUNC_VARS_DELETECURDIR)
 765 VFS_MFUNC(setfilmode, VFS_FUNC_ARGS_SETFILEMODE, VFS_FUNC_VARS_SETFILEMODE)
 766 VFS_MFUNC(setdirmode, VFS_FUNC_ARGS_SETDIRMODE, VFS_FUNC_VARS_SETDIRMODE)
 767 VFS_MFUNC(setdirunixmode, VFS_FUNC_ARGS_SETDIRUNIXMODE, VFS_FUNC_VARS_SETDIRUNIXMODE)
 768 VFS_MFUNC(setdirowner, VFS_FUNC_ARGS_SETDIROWNER, VFS_FUNC_VARS_SETDIROWNER)
 769 VFS_MFUNC(deletefile, VFS_FUNC_ARGS_DELETEFILE, VFS_FUNC_VARS_DELETEFILE)
 770 VFS_MFUNC(renamefile, VFS_FUNC_ARGS_RENAMEFILE, VFS_FUNC_VARS_RENAMEFILE)
 771 VFS_MFUNC(copyfile, VFS_FUNC_ARGS_COPYFILE, VFS_FUNC_VARS_COPYFILE)
 772 #ifdef HAVE_ACLS
 773 VFS_MFUNC(acl, VFS_FUNC_ARGS_ACL, VFS_FUNC_VARS_ACL)
 774 VFS_MFUNC(remove_acl, VFS_FUNC_ARGS_REMOVE_ACL, VFS_FUNC_VARS_REMOVE_ACL)
 775 #endif
 776 VFS_MFUNC(ea_getsize, VFS_FUNC_ARGS_EA_GETSIZE, VFS_FUNC_VARS_EA_GETSIZE)
 777 VFS_MFUNC(ea_getcontent, VFS_FUNC_ARGS_EA_GETCONTENT, VFS_FUNC_VARS_EA_GETCONTENT)
 778 VFS_MFUNC(ea_list, VFS_FUNC_ARGS_EA_LIST, VFS_FUNC_VARS_EA_LIST)
 779 VFS_MFUNC(ea_set, VFS_FUNC_ARGS_EA_SET, VFS_FUNC_VARS_EA_SET)
 780 VFS_MFUNC(ea_remove, VFS_FUNC_ARGS_EA_REMOVE, VFS_FUNC_VARS_EA_REMOVE)
 781
 782 static int vfs_validupath(VFS_FUNC_ARGS_VALIDUPATH)
 783 {
 784     return vol->vfs_modules[0]->vfs_validupath(VFS_FUNC_VARS_VALIDUPATH);
 785 }
 786
 787 /*
 788  * These function pointers get called from the lib users via vol->vfs->func.
 789  * These funcs are defined via the macros above.
 790  */
 791 static struct vfs_ops vfs_master_funcs = {
 792     vfs_validupath,
 793     vfs_chown,
 794     vfs_renamedir,
 795     vfs_deletecurdir,
 796     vfs_setfilmode,
 797     vfs_setdirmode,
 798     vfs_setdirunixmode,
 799     vfs_setdirowner,
 800     vfs_deletefile,
 801     vfs_renamefile,
 802     vfs_copyfile,
 803 #ifdef HAVE_ACLS
 804     vfs_acl,
 805     vfs_remove_acl,
 806 #endif
 807     vfs_ea_getsize,
 808     vfs_ea_getcontent,
 809     vfs_ea_list,
 810     vfs_ea_set,
 811     vfs_ea_remove
 812 };
 813
 814 /*
 815  * Primary adouble modules: v2, ea
 816  */
 817
 818 static struct vfs_ops netatalk_adouble_v2 = {
 819     /* vfs_validupath:    */ validupath_adouble,
 820     /* vfs_chown:         */ RF_chown_adouble,
 821     /* vfs_renamedir:     */ RF_renamedir_adouble,
 822     /* vfs_deletecurdir:  */ RF_deletecurdir_adouble,
 823     /* vfs_setfilmode:    */ RF_setfilmode_adouble,
 824     /* vfs_setdirmode:    */ RF_setdirmode_adouble,
 825     /* vfs_setdirunixmode:*/ RF_setdirunixmode_adouble,
 826     /* vfs_setdirowner:   */ RF_setdirowner_adouble,
 827     /* vfs_deletefile:    */ RF_deletefile_adouble,
 828     /* vfs_renamefile:    */ RF_renamefile_adouble,
 829     /* vfs_copyfile:      */ RF_copyfile_adouble,
 830     NULL
 831 };
 832
 833 static struct vfs_ops netatalk_adouble_ea = {
 834     /* vfs_validupath:    */ validupath_ea,
 835     /* vfs_chown:         */ RF_chown_ea,
 836     /* vfs_renamedir:     */ RF_renamedir_ea,
 837     /* vfs_deletecurdir:  */ RF_deletecurdir_ea,
 838     /* vfs_setfilmode:    */ RF_setfilmode_ea,
 839     /* vfs_setdirmode:    */ RF_setdirmode_ea,
 840     /* vfs_setdirunixmode:*/ RF_setdirunixmode_ea,
 841     /* vfs_setdirowner:   */ RF_setdirowner_ea,
 842     /* vfs_deletefile:    */ RF_deletefile_ea,
 843     /* vfs_renamefile:    */ RF_renamefile_ea,
 844     /* vfs_copyfile:      */ RF_copyfile_ea,
 845     NULL
 846 };
 847
 848 /*
 849  * Secondary vfs modules for Extended Attributes
 850  */
 851
 852 static struct vfs_ops netatalk_ea_adouble = {
 853     /* vfs_validupath:    */ NULL,
 854     /* vfs_chown:         */ ea_chown,
 855     /* vfs_renamedir:     */ NULL, /* ok */
 856     /* vfs_deletecurdir:  */ NULL, /* ok */
 857     /* vfs_setfilmode:    */ ea_chmod_file,
 858     /* vfs_setdirmode:    */ NULL, /* ok */
 859     /* vfs_setdirunixmode:*/ ea_chmod_dir,
 860     /* vfs_setdirowner:   */ NULL, /* ok */
 861     /* vfs_deletefile:    */ ea_deletefile,
 862     /* vfs_renamefile:    */ ea_renamefile,
 863     /* vfs_copyfile       */ ea_copyfile,
 864 #ifdef HAVE_ACLS
 865     /* vfs_acl:           */ NULL,
 866     /* vfs_remove_acl     */ NULL,
 867 #endif
 868     /* vfs_getsize        */ get_easize,
 869     /* vfs_getcontent     */ get_eacontent,
 870     /* vfs_list           */ list_eas,
 871     /* vfs_set            */ set_ea,
 872     /* vfs_remove         */ remove_ea
 873 };
 874
 875 static struct vfs_ops netatalk_ea_sys = {
 876     /* validupath:        */ NULL,
 877     /* rf_chown:          */ NULL,
 878     /* rf_renamedir:      */ NULL,
 879     /* rf_deletecurdir:   */ NULL,
 880     /* rf_setfilmode:     */ NULL,
 881     /* rf_setdirmode:     */ NULL,
 882     /* rf_setdirunixmode: */ NULL,
 883     /* rf_setdirowner:    */ NULL,
 884     /* rf_deletefile:     */ NULL,
 885     /* rf_renamefile:     */ NULL,
 886     /* vfs_copyfile:      */ sys_ea_copyfile,
 887 #ifdef HAVE_ACLS
 888     /* rf_acl:            */ NULL,
 889     /* rf_remove_acl      */ NULL,
 890 #endif
 891     /* ea_getsize         */ sys_get_easize,
 892     /* ea_getcontent      */ sys_get_eacontent,
 893     /* ea_list            */ sys_list_eas,
 894     /* ea_set             */ sys_set_ea,
 895     /* ea_remove          */ sys_remove_ea
 896 };
 897
 898 /*
 899  * Tertiary VFS modules for ACLs
 900  */
 901
 902 #ifdef HAVE_SOLARIS_ACLS
 903 static struct vfs_ops netatalk_solaris_acl_adouble = {
 904     /* validupath:        */ NULL,
 905     /* rf_chown:          */ NULL,
 906     /* rf_renamedir:      */ NULL,
 907     /* rf_deletecurdir:   */ NULL,
 908     /* rf_setfilmode:     */ NULL,
 909     /* rf_setdirmode:     */ NULL,
 910     /* rf_setdirunixmode: */ NULL,
 911     /* rf_setdirowner:    */ NULL,
 912     /* rf_deletefile:     */ NULL,
 913     /* rf_renamefile:     */ NULL,
 914     /* vfs_copyfile       */ NULL,
 915     /* rf_acl:            */ RF_solaris_acl,
 916     /* rf_remove_acl      */ RF_solaris_remove_acl,
 917     NULL
 918 };
 919 #endif
 920
 921 #ifdef HAVE_POSIX_ACLS
 922 static struct vfs_ops netatalk_posix_acl_adouble = {
 923     /* validupath:        */ NULL,
 924     /* rf_chown:          */ NULL,
 925     /* rf_renamedir:      */ NULL,
 926     /* rf_deletecurdir:   */ NULL,
 927     /* rf_setfilmode:     */ NULL,
 928     /* rf_setdirmode:     */ NULL,
 929     /* rf_setdirunixmode: */ NULL,
 930     /* rf_setdirowner:    */ NULL,
 931     /* rf_deletefile:     */ NULL,
 932     /* rf_renamefile:     */ NULL,
 933     /* vfs_copyfile       */ NULL,
 934     /* rf_acl:            */ RF_posix_acl,
 935     /* rf_remove_acl      */ RF_posix_remove_acl,
 936     NULL
 937 };
 938 #endif
 939
 940 /* ---------------- */
 941 void initvol_vfs(struct vol *vol)
 942 {
 943     vol->vfs = &vfs_master_funcs;
 944
 945     /* Default adouble stuff */
 946     if (vol->v_adouble == AD_VERSION2) {
 947         vol->vfs_modules[0] = &netatalk_adouble_v2;
 948         vol->ad_path = ad_path;
 949     } else {
 950         vol->vfs_modules[0] = &netatalk_adouble_ea;
 951 #ifdef HAVE_EAFD
 952         vol->ad_path = ad_path_ea;
 953 #else
 954         vol->ad_path = ad_path_osx;
 955 #endif
 956     }
 957
 958     /* Extended Attributes */
 959     if (vol->v_vfs_ea == AFPVOL_EA_SYS) {
 960         LOG(log_debug, logtype_afpd, "initvol_vfs: enabling EA support with native EAs");
 961         vol->vfs_modules[1] = &netatalk_ea_sys;
 962     } else if (vol->v_vfs_ea == AFPVOL_EA_AD) {
 963         LOG(log_debug, logtype_afpd, "initvol_vfs: enabling EA support with adouble files");
 964         vol->vfs_modules[1] = &netatalk_ea_adouble;
 965     } else {
 966         LOG(log_debug, logtype_afpd, "initvol_vfs: volume without EA support");
 967     }
 968
 969     /* ACLs */
 970 #ifdef HAVE_SOLARIS_ACLS
 971     vol->vfs_modules[2] = &netatalk_solaris_acl_adouble;
 972 #endif
 973 #ifdef HAVE_POSIX_ACLS
 974     vol->vfs_modules[2] = &netatalk_posix_acl_adouble;
 975 #endif
 976
 977 }