2 Copyright (c) 2004 Didier Gautheron
3 Copyright (c) 2009 Frank Lahm
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.
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.
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.
22 #endif /* HAVE_CONFIG_H */
24 #include <sys/types.h>
32 #include <atalk/afp.h>
33 #include <atalk/adouble.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>
52 typedef int (*rf_loop)(struct dirent *, char *, void *, int , mode_t );
54 /* ----------------------------- */
56 for_each_adouble(const char *from, const char *name, rf_loop fn, void *data, int flag, mode_t v_umask)
58 char buf[ MAXPATHLEN + 1];
65 if (NULL == ( dp = opendir( name)) ) {
67 LOG(log_error, logtype_afpd, "%s: opendir %s: %s", from, fullpathname(name),strerror(errno) );
72 strlcpy( buf, name, sizeof(buf));
73 strlcat( buf, "/", sizeof(buf) );
74 m = strchr( buf, '\0' );
76 while ((de = readdir(dp))) {
77 if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
81 strlcat(buf, de->d_name, sizeof(buf));
82 if (fn && (ret = fn(de, buf, data, flag, v_umask))) {
92 /*******************************************************************************
93 * classic adouble format
94 *******************************************************************************/
96 static int netatalk_name(const char *name)
98 return strcasecmp(name,".AppleDouble") &&
99 strcasecmp(name,".AppleDB") &&
100 strcasecmp(name,".AppleDesktop");
103 static int validupath_adouble(VFS_FUNC_ARGS_VALIDUPATH)
108 if (!(vol->v_flags & AFPVOL_USEDOTS))
111 return netatalk_name(name) && strcasecmp(name,".Parent");
114 /* ----------------- */
115 static int RF_chown_adouble(VFS_FUNC_ARGS_CHOWN)
120 ad_p = vol->ad_path(path, ADFLAGS_HF );
122 if ( stat( ad_p, &st ) < 0 )
123 return 0; /* ignore */
125 return chown( ad_p, uid, gid );
128 /* ----------------- */
129 static int RF_renamedir_adouble(VFS_FUNC_ARGS_RENAMEDIR)
134 /* ----------------- */
135 static int deletecurdir_adouble_loop(struct dirent *de, char *name, void *data _U_, int flag _U_, mode_t v_umask)
140 /* bail if the file exists in the current directory.
141 * note: this will not fail with dangling symlinks */
143 if (lstat(de->d_name, &st) == 0)
144 return AFPERR_DIRNEMPT;
146 if ((err = netatalk_unlink(name)))
152 static int RF_deletecurdir_adouble(VFS_FUNC_ARGS_DELETECURDIR)
156 /* delete stray .AppleDouble files. this happens to get .Parent files
158 if ((err = for_each_adouble("deletecurdir", ".AppleDouble", deletecurdir_adouble_loop, NULL, 1, vol->v_umask)))
160 return netatalk_rmdir(-1, ".AppleDouble" );
163 /* ----------------- */
164 static int adouble_setfilmode(const char * name, mode_t mode, struct stat *st, mode_t v_umask)
166 return setfilmode(name, ad_hf_mode(mode), st, v_umask);
169 static int RF_setfilmode_adouble(VFS_FUNC_ARGS_SETFILEMODE)
171 return adouble_setfilmode(vol->ad_path(name, ADFLAGS_HF ), mode, st, vol->v_umask);
174 /* ----------------- */
175 static int RF_setdirunixmode_adouble(VFS_FUNC_ARGS_SETDIRUNIXMODE)
177 const char *adouble = vol->ad_path(name, ADFLAGS_DIR );
178 int dropbox = vol->v_flags;
180 if (dir_rx_set(mode)) {
181 if (stickydirmode(ad_dir(adouble), DIRBITS | mode, dropbox, vol->v_umask) < 0 )
185 if (adouble_setfilmode(vol->ad_path(name, ADFLAGS_DIR ), mode, st, vol->v_umask) < 0)
188 if (!dir_rx_set(mode)) {
189 if (stickydirmode(ad_dir(adouble), DIRBITS | mode, dropbox, vol->v_umask) < 0 )
195 /* ----------------- */
196 static int setdirmode_adouble_loop(struct dirent *de _U_, char *name, void *data, int flag, mode_t v_umask)
198 mode_t hf_mode = *(mode_t *)data;
201 if ( stat( name, &st ) < 0 ) {
204 LOG(log_error, logtype_afpd, "setdirmode: stat %s: %s", name, strerror(errno) );
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? */
214 static int RF_setdirmode_adouble(VFS_FUNC_ARGS_SETDIRMODE)
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);
221 if (dir_rx_set(mode)) {
222 if (stickydirmode(ad_dir(adouble), DIRBITS | mode, dropbox, vol->v_umask) < 0)
226 if (for_each_adouble("setdirmode", adouble_p, setdirmode_adouble_loop, &hf_mode, vol_noadouble(vol), vol->v_umask))
229 if (!dir_rx_set(mode)) {
230 if (stickydirmode(ad_dir(adouble), DIRBITS | mode, dropbox, vol->v_umask) < 0)
236 /* ----------------- */
237 static int setdirowner_adouble_loop(struct dirent *de _U_, char *name, void *data, int flag _U_, mode_t v_umask _U_)
239 struct perm *owner = data;
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 */
249 static int RF_setdirowner_adouble(VFS_FUNC_ARGS_SETDIROWNER)
251 int noadouble = vol_noadouble(vol);
259 adouble_p = ad_dir(vol->ad_path(name, ADFLAGS_DIR ));
261 if (for_each_adouble("setdirowner", adouble_p, setdirowner_adouble_loop, &owner, noadouble, vol->v_umask))
265 * We cheat: we know that chown doesn't do anything.
267 if ( stat( ".AppleDouble", &st ) < 0) {
268 if (errno == ENOENT && noadouble)
270 LOG(log_error, logtype_afpd, "setdirowner: stat %s: %s", fullpathname(".AppleDouble"), strerror(errno) );
273 if ( gid && gid != st.st_gid && chown( ".AppleDouble", uid, gid ) < 0 && errno != EPERM ) {
274 LOG(log_debug, logtype_afpd, "setdirowner: chown %d/%d %s: %s",
275 uid, gid,fullpathname(".AppleDouble"), strerror(errno) );
276 /* return ( -1 ); Sometimes this is okay */
281 /* ----------------- */
282 static int RF_deletefile_adouble(VFS_FUNC_ARGS_DELETEFILE)
284 return netatalk_unlinkat(dirfd, vol->ad_path(file, ADFLAGS_HF));
287 /* ----------------- */
288 static int RF_renamefile_adouble(VFS_FUNC_ARGS_RENAMEFILE)
290 char adsrc[ MAXPATHLEN + 1];
293 strcpy( adsrc, vol->ad_path(src, 0 ));
294 if (unix_rename(dirfd, adsrc, -1, vol->ad_path(dst, 0 )) < 0) {
298 if (errno == ENOENT) {
301 if (lstatat(dirfd, adsrc, &st)) /* source has no ressource fork, */
304 /* We are here because :
305 * -there's no dest folder.
306 * -there's no .AppleDouble in the dest folder.
307 * if we use the struct adouble passed in parameter it will not
308 * create .AppleDouble if the file is already opened, so we
309 * use a diff one, it's not a pb,ie it's not the same file, yet.
312 if (ad_open(&ad, dst, ADFLAGS_HF | ADFLAGS_RDWR | ADFLAGS_CREATE, 0666) == 0) {
313 ad_close(&ad, ADFLAGS_HF);
314 if (!unix_rename(dirfd, adsrc, -1, vol->ad_path(dst, 0 )) )
319 else { /* it's something else, bail out */
331 static int RF_copyfile_adouble(VFS_FUNC_ARGS_COPYFILE)
332 /* const struct vol *vol, int sfd, const char *src, const char *dst */
335 bstring s = NULL, d = NULL;
340 const char *name = NULL;
341 const char *dir = NULL;
344 EC_ZERO(stat(dst, &st));
346 if (S_ISDIR(st.st_mode)) {
347 /* build src path to AppleDouble file*/
348 EC_NULL(s = bfromcstr(src));
349 EC_ZERO(bcatcstr(s, "/.AppleDouble/.Parent"));
351 /* build dst path to AppleDouble file*/
352 EC_NULL(d = bfromcstr(dst));
353 EC_ZERO(bcatcstr(d, "/.AppleDouble/.Parent"));
357 /* build src path to AppleDouble file*/
358 EC_NULL(dup1 = strdup(src));
359 EC_NULL(name = basename(strdup(dup1)));
361 EC_NULL(dup2 = strdup(src));
362 EC_NULL(dir = dirname(dup2));
363 EC_NULL(s = bfromcstr(dir));
364 EC_ZERO(bcatcstr(s, "/.AppleDouble/"));
365 EC_ZERO(bcatcstr(s, name));
367 /* build dst path to AppleDouble file*/
368 EC_NULL(dup4 = strdup(dst));
369 EC_NULL(name = basename(strdup(dup4)));
371 EC_NULL(dup3 = strdup(dst));
372 EC_NULL(dir = dirname(dup3));
373 EC_NULL(d = bfromcstr(dir));
374 EC_ZERO(bcatcstr(d, "/.AppleDouble/"));
375 EC_ZERO(bcatcstr(d, name));
378 EC_ZERO(copy_file(sfd, cfrombstr(s), cfrombstr(d), 0666));
383 if (dup1) free(dup1);
384 if (dup2) free(dup2);
385 if (dup3) free(dup3);
386 if (dup4) free(dup4);
391 #ifdef HAVE_SOLARIS_ACLS
392 static int RF_solaris_acl(VFS_FUNC_ARGS_ACL)
394 static char buf[ MAXPATHLEN + 1];
398 if ((stat(path, &st)) != 0)
400 if (S_ISDIR(st.st_mode)) {
401 len = snprintf(buf, MAXPATHLEN, "%s/.AppleDouble",path);
402 if (len < 0 || len >= MAXPATHLEN)
404 /* set acl on .AppleDouble dir first */
405 if ((acl(buf, cmd, count, aces)) != 0)
407 /* now set ACL on ressource fork */
408 if ((acl(vol->ad_path(path, ADFLAGS_DIR), cmd, count, aces)) != 0)
411 /* set ACL on ressource fork */
412 if ((acl(vol->ad_path(path, ADFLAGS_HF), cmd, count, aces)) != 0)
418 static int RF_solaris_remove_acl(VFS_FUNC_ARGS_REMOVE_ACL)
421 static char buf[ MAXPATHLEN + 1];
425 len = snprintf(buf, MAXPATHLEN, "%s/.AppleDouble",path);
426 if (len < 0 || len >= MAXPATHLEN)
428 /* remove ACL from .AppleDouble/.Parent first */
429 if ((ret = remove_acl_vfs(vol->ad_path(path, ADFLAGS_DIR))) != AFP_OK)
431 /* now remove from .AppleDouble dir */
432 if ((ret = remove_acl_vfs(buf)) != AFP_OK)
435 /* remove ACL from ressource fork */
436 if ((ret = remove_acl_vfs(vol->ad_path(path, ADFLAGS_HF))) != AFP_OK)
443 #ifdef HAVE_POSIX_ACLS
444 static int RF_posix_acl(VFS_FUNC_ARGS_ACL)
447 static char buf[ MAXPATHLEN + 1];
451 if (S_ISDIR(st.st_mode)) {
452 len = snprintf(buf, MAXPATHLEN, "%s/.AppleDouble",path);
453 if (len < 0 || len >= MAXPATHLEN)
455 /* set acl on .AppleDouble dir first */
456 EC_ZERO_LOG(acl_set_file(buf, type, acl));
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));
462 /* set ACL on ressource fork */
463 EC_ZERO_LOG(acl_set_file(vol->ad_path(path, ADFLAGS_HF), type, acl));
472 static int RF_posix_remove_acl(VFS_FUNC_ARGS_REMOVE_ACL)
475 static char buf[ MAXPATHLEN + 1];
479 len = snprintf(buf, MAXPATHLEN, "%s/.AppleDouble",path);
480 if (len < 0 || len >= MAXPATHLEN)
482 /* remove ACL from .AppleDouble/.Parent first */
483 EC_ZERO_LOG_ERR(remove_acl_vfs(vol->ad_path(path, ADFLAGS_DIR)), AFPERR_MISC);
485 /* now remove from .AppleDouble dir */
486 EC_ZERO_LOG_ERR(remove_acl_vfs(buf), AFPERR_MISC);
488 /* remove ACL from ressource fork */
489 EC_ZERO_LOG_ERR(remove_acl_vfs(vol->ad_path(path, ADFLAGS_HF)), AFPERR_MISC);
497 /*************************************************************************
499 ************************************************************************/
500 static int validupath_ea(VFS_FUNC_ARGS_VALIDUPATH)
505 if (!(vol->v_flags & AFPVOL_USEDOTS))
512 return netatalk_name(name) && strcasecmp(name,".Parent");
515 /* ----------------- */
516 static int RF_chown_ea(VFS_FUNC_ARGS_CHOWN)
519 return chown(vol->ad_path(path, ADFLAGS_HF ), uid, gid);
524 /* ---------------- */
525 static int RF_renamedir_ea(VFS_FUNC_ARGS_RENAMEDIR)
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_)
533 if (de->d_name[0] != '.' || de->d_name[0] == '_')
539 static int deletecurdir_ea_osx_loop(struct dirent *de, char *name, void *data _U_, int flag _U_, mode_t v_umask _U_)
543 if ((ret = netatalk_unlink(name)) != 0)
549 /* ---------------- */
550 static int RF_deletecurdir_ea(VFS_FUNC_ARGS_DELETECURDIR)
554 /* delete stray ._AppleDouble files */
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,
561 return AFPERR_DIRNEMPT;
565 /* Now delete orphaned ._ files */
566 if ((err = for_each_adouble("deletecurdir_ea_osx", ".",
567 deletecurdir_ea_osx_loop,
575 /* ---------------- */
576 static int RF_setdirunixmode_ea(VFS_FUNC_ARGS_SETDIRUNIXMODE)
583 static int RF_setfilmode_ea(VFS_FUNC_ARGS_SETFILEMODE)
586 return adouble_setfilmode(vol->ad_path(name, ADFLAGS_HF ), mode, st, vol->v_umask);
591 /* ---------------- */
592 static int RF_setdirmode_ea(VFS_FUNC_ARGS_SETDIRMODE)
599 /* ---------------- */
600 static int RF_setdirowner_ea(VFS_FUNC_ARGS_SETDIROWNER)
607 static int RF_deletefile_ea(VFS_FUNC_ARGS_DELETEFILE)
610 return netatalk_unlinkat(dirfd, vol->ad_path(file, ADFLAGS_HF));
614 static int RF_copyfile_ea(VFS_FUNC_ARGS_COPYFILE)
619 if (copy_ea(AD_EA_META, sfd, src, dst, 0666) != 0)
624 int sfile = -1, dfile = -1, sea = -1, dea = -1;
626 if ((sfile = openat(sfd, src, O_RDONLY)) == -1) {
631 if ((dfile = open(dts, O_WRONLY)) == -1) {
636 if ((sea = openat(sfile, AD_EA_RESO, O_RDONLY | O_XATTR)) == -1) {
641 if ((dea = openat(dfile, AD_EA_RESO, O_RDWR | O_CREAT | O_XATTR)) == -1) {
646 ret = copy_file_fd(sea, dea);
649 if (sfile != -1) close(sfile);
650 if (dfile != -1) close(dfile);
651 if (sea != -1) close(sea);
652 if (dea != -1) close(dea);
658 bstring s = NULL, d = NULL;
663 const char *name = NULL;
664 const char *dir = NULL;
668 /* build src path to ._ file*/
669 EC_NULL(dup1 = strdup(src));
670 EC_NULL(name = basename(strdup(dup1)));
672 EC_NULL(dup2 = strdup(src));
673 EC_NULL(dir = dirname(dup2));
674 EC_NULL(s = bfromcstr(dir));
675 EC_ZERO(bcatcstr(s, "/._"));
676 EC_ZERO(bcatcstr(s, name));
678 /* build dst path to ._file*/
679 EC_NULL(dup4 = strdup(dst));
680 EC_NULL(name = basename(strdup(dup4)));
682 EC_NULL(dup3 = strdup(dst));
683 EC_NULL(dir = dirname(dup3));
684 EC_NULL(d = bfromcstr(dir));
685 EC_ZERO(bcatcstr(d, "/._"));
686 EC_ZERO(bcatcstr(d, name));
688 EC_ZERO(copy_file(sfd, cfrombstr(s), cfrombstr(d), 0666));
702 /* ---------------- */
703 static int RF_renamefile_ea(VFS_FUNC_ARGS_RENAMEFILE)
706 char adsrc[ MAXPATHLEN + 1];
709 strcpy( adsrc, vol->ad_path(src, 0 ));
711 if (unix_rename(dirfd, adsrc, -1, vol->ad_path(dst, 0 )) < 0) {
715 if (errno == ENOENT && lstatat(dirfd, adsrc, &st)) /* source has no ressource fork, */
725 /********************************************************************************************
727 ********************************************************************************************/
730 * Up until we really start stacking many VFS modules on top of one another or use
731 * dynamic module loading like we do for UAMs, up until then we just stack VFS modules
732 * via an fixed size array.
733 * All VFS funcs must return AFP_ERR codes. When a func in the chain returns an error
734 * this error code will be returned to the caller, BUT the chain in followed and all
735 * following funcs are called in order to give them a chance.
739 * Define most VFS funcs with macros as they all do the same.
740 * Only "ad_path" and "validupath" will NOT do stacking and only
741 * call the func from the first module.
744 #define VFS_MFUNC(name, args, vars) \
745 static int vfs_ ## name(args) \
747 int i = 0, ret = AFP_OK, err; \
748 while (vol->vfs_modules[i]) { \
749 if (vol->vfs_modules[i]->vfs_ ## name) { \
750 err = vol->vfs_modules[i]->vfs_ ## name (vars); \
751 if ((ret == AFP_OK) && (err != AFP_OK)) \
759 VFS_MFUNC(chown, VFS_FUNC_ARGS_CHOWN, VFS_FUNC_VARS_CHOWN)
760 VFS_MFUNC(renamedir, VFS_FUNC_ARGS_RENAMEDIR, VFS_FUNC_VARS_RENAMEDIR)
761 VFS_MFUNC(deletecurdir, VFS_FUNC_ARGS_DELETECURDIR, VFS_FUNC_VARS_DELETECURDIR)
762 VFS_MFUNC(setfilmode, VFS_FUNC_ARGS_SETFILEMODE, VFS_FUNC_VARS_SETFILEMODE)
763 VFS_MFUNC(setdirmode, VFS_FUNC_ARGS_SETDIRMODE, VFS_FUNC_VARS_SETDIRMODE)
764 VFS_MFUNC(setdirunixmode, VFS_FUNC_ARGS_SETDIRUNIXMODE, VFS_FUNC_VARS_SETDIRUNIXMODE)
765 VFS_MFUNC(setdirowner, VFS_FUNC_ARGS_SETDIROWNER, VFS_FUNC_VARS_SETDIROWNER)
766 VFS_MFUNC(deletefile, VFS_FUNC_ARGS_DELETEFILE, VFS_FUNC_VARS_DELETEFILE)
767 VFS_MFUNC(renamefile, VFS_FUNC_ARGS_RENAMEFILE, VFS_FUNC_VARS_RENAMEFILE)
768 VFS_MFUNC(copyfile, VFS_FUNC_ARGS_COPYFILE, VFS_FUNC_VARS_COPYFILE)
770 VFS_MFUNC(acl, VFS_FUNC_ARGS_ACL, VFS_FUNC_VARS_ACL)
771 VFS_MFUNC(remove_acl, VFS_FUNC_ARGS_REMOVE_ACL, VFS_FUNC_VARS_REMOVE_ACL)
773 VFS_MFUNC(ea_getsize, VFS_FUNC_ARGS_EA_GETSIZE, VFS_FUNC_VARS_EA_GETSIZE)
774 VFS_MFUNC(ea_getcontent, VFS_FUNC_ARGS_EA_GETCONTENT, VFS_FUNC_VARS_EA_GETCONTENT)
775 VFS_MFUNC(ea_list, VFS_FUNC_ARGS_EA_LIST, VFS_FUNC_VARS_EA_LIST)
776 VFS_MFUNC(ea_set, VFS_FUNC_ARGS_EA_SET, VFS_FUNC_VARS_EA_SET)
777 VFS_MFUNC(ea_remove, VFS_FUNC_ARGS_EA_REMOVE, VFS_FUNC_VARS_EA_REMOVE)
779 static int vfs_validupath(VFS_FUNC_ARGS_VALIDUPATH)
781 return vol->vfs_modules[0]->vfs_validupath(VFS_FUNC_VARS_VALIDUPATH);
785 * These function pointers get called from the lib users via vol->vfs->func.
786 * These funcs are defined via the macros above.
788 static struct vfs_ops vfs_master_funcs = {
812 * Primary adouble modules: v2, ea
815 static struct vfs_ops netatalk_adouble_v2 = {
816 /* vfs_validupath: */ validupath_adouble,
817 /* vfs_chown: */ RF_chown_adouble,
818 /* vfs_renamedir: */ RF_renamedir_adouble,
819 /* vfs_deletecurdir: */ RF_deletecurdir_adouble,
820 /* vfs_setfilmode: */ RF_setfilmode_adouble,
821 /* vfs_setdirmode: */ RF_setdirmode_adouble,
822 /* vfs_setdirunixmode:*/ RF_setdirunixmode_adouble,
823 /* vfs_setdirowner: */ RF_setdirowner_adouble,
824 /* vfs_deletefile: */ RF_deletefile_adouble,
825 /* vfs_renamefile: */ RF_renamefile_adouble,
826 /* vfs_copyfile: */ RF_copyfile_adouble,
830 static struct vfs_ops netatalk_adouble_ea = {
831 /* vfs_validupath: */ validupath_ea,
832 /* vfs_chown: */ RF_chown_ea,
833 /* vfs_renamedir: */ RF_renamedir_ea,
834 /* vfs_deletecurdir: */ RF_deletecurdir_ea,
835 /* vfs_setfilmode: */ RF_setfilmode_ea,
836 /* vfs_setdirmode: */ RF_setdirmode_ea,
837 /* vfs_setdirunixmode:*/ RF_setdirunixmode_ea,
838 /* vfs_setdirowner: */ RF_setdirowner_ea,
839 /* vfs_deletefile: */ RF_deletefile_ea,
840 /* vfs_renamefile: */ RF_renamefile_ea,
841 /* vfs_copyfile: */ RF_copyfile_ea,
846 * Secondary vfs modules for Extended Attributes
849 static struct vfs_ops netatalk_ea_adouble = {
850 /* vfs_validupath: */ NULL,
851 /* vfs_chown: */ ea_chown,
852 /* vfs_renamedir: */ NULL, /* ok */
853 /* vfs_deletecurdir: */ NULL, /* ok */
854 /* vfs_setfilmode: */ ea_chmod_file,
855 /* vfs_setdirmode: */ NULL, /* ok */
856 /* vfs_setdirunixmode:*/ ea_chmod_dir,
857 /* vfs_setdirowner: */ NULL, /* ok */
858 /* vfs_deletefile: */ ea_deletefile,
859 /* vfs_renamefile: */ ea_renamefile,
860 /* vfs_copyfile */ ea_copyfile,
863 /* vfs_remove_acl */ NULL,
865 /* vfs_getsize */ get_easize,
866 /* vfs_getcontent */ get_eacontent,
867 /* vfs_list */ list_eas,
868 /* vfs_set */ set_ea,
869 /* vfs_remove */ remove_ea
872 static struct vfs_ops netatalk_ea_sys = {
873 /* validupath: */ NULL,
874 /* rf_chown: */ NULL,
875 /* rf_renamedir: */ NULL,
876 /* rf_deletecurdir: */ NULL,
877 /* rf_setfilmode: */ NULL,
878 /* rf_setdirmode: */ NULL,
879 /* rf_setdirunixmode: */ NULL,
880 /* rf_setdirowner: */ NULL,
881 /* rf_deletefile: */ NULL,
882 /* rf_renamefile: */ NULL,
883 /* vfs_copyfile: */ sys_ea_copyfile,
886 /* rf_remove_acl */ NULL,
888 /* ea_getsize */ sys_get_easize,
889 /* ea_getcontent */ sys_get_eacontent,
890 /* ea_list */ sys_list_eas,
891 /* ea_set */ sys_set_ea,
892 /* ea_remove */ sys_remove_ea
896 * Tertiary VFS modules for ACLs
899 #ifdef HAVE_SOLARIS_ACLS
900 static struct vfs_ops netatalk_solaris_acl_adouble = {
901 /* validupath: */ NULL,
902 /* rf_chown: */ NULL,
903 /* rf_renamedir: */ NULL,
904 /* rf_deletecurdir: */ NULL,
905 /* rf_setfilmode: */ NULL,
906 /* rf_setdirmode: */ NULL,
907 /* rf_setdirunixmode: */ NULL,
908 /* rf_setdirowner: */ NULL,
909 /* rf_deletefile: */ NULL,
910 /* rf_renamefile: */ NULL,
911 /* vfs_copyfile */ NULL,
912 /* rf_acl: */ RF_solaris_acl,
913 /* rf_remove_acl */ RF_solaris_remove_acl,
918 #ifdef HAVE_POSIX_ACLS
919 static struct vfs_ops netatalk_posix_acl_adouble = {
920 /* validupath: */ NULL,
921 /* rf_chown: */ NULL,
922 /* rf_renamedir: */ NULL,
923 /* rf_deletecurdir: */ NULL,
924 /* rf_setfilmode: */ NULL,
925 /* rf_setdirmode: */ NULL,
926 /* rf_setdirunixmode: */ NULL,
927 /* rf_setdirowner: */ NULL,
928 /* rf_deletefile: */ NULL,
929 /* rf_renamefile: */ NULL,
930 /* vfs_copyfile */ NULL,
931 /* rf_acl: */ RF_posix_acl,
932 /* rf_remove_acl */ RF_posix_remove_acl,
937 /* ---------------- */
938 void initvol_vfs(struct vol *vol)
940 vol->vfs = &vfs_master_funcs;
942 /* Default adouble stuff */
943 if (vol->v_adouble == AD_VERSION2) {
944 vol->vfs_modules[0] = &netatalk_adouble_v2;
945 vol->ad_path = ad_path;
947 vol->vfs_modules[0] = &netatalk_adouble_ea;
948 vol->ad_path = ad_path_ea;
951 /* Extended Attributes */
952 if (vol->v_vfs_ea == AFPVOL_EA_SYS) {
953 LOG(log_debug, logtype_afpd, "initvol_vfs: enabling EA support with native EAs");
954 vol->vfs_modules[1] = &netatalk_ea_sys;
955 } else if (vol->v_vfs_ea == AFPVOL_EA_AD) {
956 LOG(log_debug, logtype_afpd, "initvol_vfs: enabling EA support with adouble files");
957 vol->vfs_modules[1] = &netatalk_ea_adouble;
959 LOG(log_debug, logtype_afpd, "initvol_vfs: volume without EA support");
963 #ifdef HAVE_SOLARIS_ACLS
964 vol->vfs_modules[2] = &netatalk_solaris_acl_adouble;
966 #ifdef HAVE_POSIX_ACLS
967 vol->vfs_modules[2] = &netatalk_posix_acl_adouble;