adouble.h File Reference

Part of Netatalk's AppleDouble implementatation. More...

#include <fcntl.h>
#include <inttypes.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

Go to the source code of this file.

Data Structures
struct	ad_entry
struct	adf_lock_t
struct	ad_fd
struct	adouble_fops
struct	adouble

Macros
#define	AD_VERSION2   0x00020000
#define	AD_VERSION_EA   0x00020002
#define	AD_VERSION   AD_VERSION_EA
#define	ADEID_DFORK   1
#define	ADEID_RFORK   2
#define	ADEID_NAME   3
#define	ADEID_COMMENT   4
#define	ADEID_ICONBW   5
#define	ADEID_ICONCOL   6
#define	ADEID_FILEI   7
#define	ADEID_FILEDATESI   8
#define	ADEID_FINDERI   9
#define	ADEID_MACFILEI   10
#define	ADEID_PRODOSFILEI   11
#define	ADEID_MSDOSFILEI   12
#define	ADEID_SHORTNAME   13
#define	ADEID_AFPFILEI   14
#define	ADEID_DID   15
#define	ADEID_PRIVDEV   16
#define	ADEID_PRIVINO   17
#define	ADEID_PRIVSYN   18
#define	ADEID_PRIVID   19
#define	ADEID_MAX   (ADEID_PRIVID + 1)
#define	AD_DEV   0x80444556
#define	AD_INO   0x80494E4F
#define	AD_SYN   0x8053594E
#define	AD_ID   0x8053567E
#define	AD_APPLESINGLE_MAGIC   0x00051600
#define	AD_APPLEDOUBLE_MAGIC   0x00051607
#define	AD_MAGIC   AD_APPLEDOUBLE_MAGIC
#define	ADEDLEN_MAGIC   4
#define	ADEDLEN_VERSION   4
#define	ADEDLEN_FILLER   16
#define	ADEDLEN_NENTRIES   2
#define	AD_HEADER_LEN   (ADEDLEN_MAGIC + ADEDLEN_VERSION + ADEDLEN_FILLER + ADEDLEN_NENTRIES)
#define	AD_ENTRY_LEN   12
#define	ADEDLEN_NAME   255
#define	ADEDLEN_COMMENT   200
#define	ADEDLEN_FILEI   16
#define	ADEDLEN_FINDERI   32
#define	ADEDLEN_FILEDATESI   16
#define	ADEDLEN_SHORTNAME   12
#define	ADEDLEN_AFPFILEI   4
#define	ADEDLEN_MACFILEI   4
#define	ADEDLEN_PRODOSFILEI   8
#define	ADEDLEN_MSDOSFILEI   2
#define	ADEDLEN_ICONBW   128
#define	ADEDLEN_ICONCOL   1024
#define	ADEDLEN_DID   4
#define	ADEDLEN_PRIVDEV   8
#define	ADEDLEN_PRIVINO   8
#define	ADEDLEN_PRIVSYN   8
#define	ADEDLEN_PRIVID   4
#define	ADEID_NUM_V2   13
#define	ADEID_NUM_EA   8
#define	ADEID_NUM_OSX   2
#define	AD_DATASZ2
#define	AD_DATASZ_EA
#define	AD_DATASZ_OSX   (AD_HEADER_LEN + (ADEID_NUM_OSX * AD_ENTRY_LEN) + ADEDLEN_FINDERI)
#define	AD_DATASZ_MAX   1024
#define	AD_DATASZ   AD_DATASZ2
#define	ADEDOFF_FINDERI_OSX   (AD_HEADER_LEN + ADEID_NUM_OSX*AD_ENTRY_LEN)
#define	ADEDOFF_RFORK_OSX   (ADEDOFF_FINDERI_OSX + ADEDLEN_FINDERI)
#define	AD_SYMLINK   -2
#define	AD_INITED   0xad494e54
#define	AD_CLOSED   0xadc10ced
#define	ADFLAGS_DF   (1<<0)
#define	ADFLAGS_RF   (1<<1)
#define	ADFLAGS_HF   (1<<2)
#define	ADFLAGS_DIR   (1<<3)
#define	ADFLAGS_NOHF   (1<<4)
#define	ADFLAGS_NORF   (1<<5)
#define	ADFLAGS_CHECK_OF   (1<<6)
#define	ADFLAGS_SETSHRMD   (1<<7)
#define	ADFLAGS_RDWR   (1<<8)
#define	ADFLAGS_RDONLY   (1<<9)
#define	ADFLAGS_CREATE   (1<<10)
#define	ADFLAGS_EXCL   (1<<11)
#define	ADFLAGS_TRUNC   (1<<12)
#define	ADVOL_NODEV   (1 << 0)
#define	ADVOL_RO   (1 << 1)
#define	ADVOL_UNIXPRIV   (1 << 2)
#define	ADVOL_INVDOTS   (1 << 3)
#define	ADVOL_FOLLO_SYML   (1 << 4)
#define	ADVOL_FORCE_STICKY_XATTR   (1 << 5)
#define	ADLOCK_CLR   (0)
#define	ADLOCK_RD   (1<<0)
#define	ADLOCK_WR   (1<<1)
#define	ADLOCK_MASK   (ADLOCK_RD | ADLOCK_WR)
#define	ADLOCK_UPGRADE   (1<<2)
#define	ADLOCK_FILELOCK   (1<<3)
#define	AD_FILELOCK_BASE   (UINT32_C(0x7FFFFFFF) - 9)
#define	BYTELOCK_MAX   (AD_FILELOCK_BASE - 1)
#define	AD_FILELOCK_OPEN_WR   (AD_FILELOCK_BASE + 0)
#define	AD_FILELOCK_OPEN_RD   (AD_FILELOCK_BASE + 1)
#define	AD_FILELOCK_RSRC_OPEN_WR   (AD_FILELOCK_BASE + 2)
#define	AD_FILELOCK_RSRC_OPEN_RD   (AD_FILELOCK_BASE + 3)
#define	AD_FILELOCK_DENY_WR   (AD_FILELOCK_BASE + 4)
#define	AD_FILELOCK_DENY_RD   (AD_FILELOCK_BASE + 5)
#define	AD_FILELOCK_RSRC_DENY_WR   (AD_FILELOCK_BASE + 6)
#define	AD_FILELOCK_RSRC_DENY_RD   (AD_FILELOCK_BASE + 7)
#define	AD_FILELOCK_OPEN_NONE   (AD_FILELOCK_BASE + 8)
#define	AD_FILELOCK_RSRC_OPEN_NONE   (AD_FILELOCK_BASE + 9)
#define	AD_DATE_CREATE   0
#define	AD_DATE_MODIFY   4
#define	AD_DATE_BACKUP   8
#define	AD_DATE_ACCESS   12
#define	AD_DATE_MASK
#define	AD_DATE_UNIX   (1 << 10)
#define	AD_DATE_START   htonl(0x80000000)
#define	AD_DATE_DELTA   946684800
#define	AD_DATE_FROM_UNIX(x)
#define	AD_DATE_TO_UNIX(x)
#define	FINDERINFO_FRTYPEOFF   0
#define	FINDERINFO_FRCREATOFF   4
#define	FINDERINFO_FRFLAGOFF   8
#define	FINDERINFO_ISONDESK   (1)
#define	FINDERINFO_COLOR   (0x0e)
#define	FINDERINFO_HIDEEXT   (1<<4)
#define	FINDERINFO_ISHARED   (1<<6)
#define	FINDERINFO_HASNOINITS   (1<<7)
#define	FINDERINFO_HASBEENINITED   (1<<8)
#define	FINDERINFO_HASCUSTOMICON   (1<<10)
#define	FINDERINFO_ISSTATIONNERY   (1<<11)
#define	FINDERINFO_NAMELOCKED   (1<<12)
#define	FINDERINFO_HASBUNDLE   (1<<13)
#define	FINDERINFO_INVISIBLE   (1<<14)
#define	FINDERINFO_ISALIAS   (1<<15)
#define	FINDERINFO_FRVIEWOFF   14
#define	FINDERINFO_CUSTOMICON   0x4
#define	FINDERINFO_CLOSEDVIEW   0x100
#define	ATTRBIT_INVISIBLE   (1<<0)
#define	ATTRBIT_MULTIUSER   (1<<1)
#define	ATTRBIT_SYSTEM   (1<<2)
#define	ATTRBIT_DOPEN   (1<<3)
#define	ATTRBIT_ROPEN   (1<<4)
#define	ATTRBIT_NOWRITE   (1<<5)
#define	ATTRBIT_BACKUP   (1<<6)
#define	ATTRBIT_NORENAME   (1<<7)
#define	ATTRBIT_NODELETE   (1<<8)
#define	ATTRBIT_NOCOPY   (1<<10)
#define	ATTRBIT_SETCLR   (1<<15)
#define	ATTRBIT_EXPFLDR   (1<<1)
#define	ATTRBIT_MOUNTED   (1<<3)
#define	ATTRBIT_SHARED   (1<<4)
#define	AD_AFPFILEI_OWNER   (1 << 0)
#define	AD_AFPFILEI_GROUP   (1 << 1)
#define	AD_AFPFILEI_BLANKACCESS   (1 << 2)
#define	AD_FILLER_NETATALK   "Netatalk "
#define	AD_FILLER_OSX   "Mac OS X"
#define	ad_data_fileno(ad)
#define	ad_reso_fileno(ad)
#define	ad_meta_fileno(ad)
#define	AD_DATA_OPEN(ad)
#define	AD_META_OPEN(ad)
#define	AD_RSRC_OPEN(ad)
#define	ad_getversion(ad)
#define	ad_getentrylen(ad, eid)
#define	ad_setentrylen(ad, eid, len)
#define	ad_setentryoff(ad, eid, off)
#define	ad_get_RF_flags(ad)
#define	ad_get_MD_flags(ad)
#define	ad_ref(ad)
#define	ad_unref(ad)
#define	ad_get_syml_opt(ad)

Typedefs
typedef uint32_t	cnid_t
typedef struct adf_lock_t	adf_lock_t

Functions
int	ad_rebuild_adouble_header_v2 (struct adouble *)
int	ad_rebuild_adouble_header_ea (struct adouble *)
int	ad_rebuild_adouble_header_osx (struct adouble *ad, char *adbuf)
int	ad_copy_header (struct adouble *, struct adouble *)
int	ad_flush (struct adouble *)
int	ad_close (struct adouble *, int)
int	fsetrsrcea (struct adouble *ad, int fd, const char *eaname, const void *value, size_t size, int flags)
int	ad_testlock (struct adouble *adp, int eid, off_t off)
	Test for a share mode lock.
uint16_t	ad_openforks (struct adouble *adp, uint16_t)
	Return if a file is open by another process.
int	ad_lock (struct adouble *, uint32_t eid, int type, off_t off, off_t len, int fork)
void	ad_unlock (struct adouble *, int fork, int unlckbrl)
int	ad_tmplock (struct adouble *, uint32_t eid, int type, off_t off, off_t len, int fork)
void *	ad_entry (const struct adouble *ad, int eid)
off_t	ad_getentryoff (const struct adouble *ad, int eid)
const char *	adflags2logstr (int adflags)
int	ad_setfuid (const uid_t)
uid_t	ad_getfuid (void)
char *	ad_dir (const char *)
	Support inherited protection modes for AppleDouble files. The supplied mode is ANDed with the parent directory's mask value in lieu of "umask", and that value is returned.
const char *	ad_path (const char *, int)
	Put the .AppleDouble where it needs to be:
const char *	ad_path_ea (const char *, int)
const char *	ad_path_osx (const char *path, int adflags)
int	ad_mode (const char *, mode_t)
int	ad_mkdir (const char *, mode_t)
void	ad_init (struct adouble *, const struct vol *)
void	ad_init_old (struct adouble *ad, int flags, int options)
int	ad_init_offsets (struct adouble *ad)
int	ad_open (struct adouble *ad, const char *path, int adflags,...)
	Open data-, metadata(header)- or resource fork.
int	ad_openat (struct adouble *, int dirfd, const char *path, int adflags,...)
int	ad_refresh (const char *path, struct adouble *)
int	ad_stat (const char *, struct stat *)
int	ad_metadata (const char *, int, struct adouble *)
	open metadata, possibly as root
int	ad_metadataat (int, const char *, int, struct adouble *)
mode_t	ad_hf_mode (mode_t mode)
int	ad_valid_header_osx (const char *path)
off_t	ad_reso_size (const char *path, int adflags, struct adouble *ad)
int	ad_convert (const char *path, const struct stat *sp, const struct vol *vol, const char **newpath)
	AppleDouble and encoding conversion on the fly.
int	sys_ftruncate (int fd, off_t length)
ssize_t	ad_read (struct adouble *, uint32_t, off_t, char *, size_t)
ssize_t	ad_pread (struct ad_fd *, void *, size_t, off_t)
ssize_t	ad_write (struct adouble *, uint32_t, off_t, int, const char *, size_t)
ssize_t	adf_pread (struct ad_fd *, void *, size_t, off_t)
ssize_t	adf_pwrite (struct ad_fd *, const void *, size_t, off_t)
int	ad_dtruncate (struct adouble *, off_t)
int	ad_rtruncate (struct adouble *, const char *, off_t)
int	copy_fork (int eid, struct adouble *add, struct adouble *ads, uint8_t *buf, size_t buflen)
off_t	ad_size (const struct adouble *, uint32_t)
int	ad_setdate (struct adouble *, unsigned int, uint32_t)
int	ad_getdate (const struct adouble *, unsigned int, uint32_t *)
int	ad_setattr (const struct adouble *, const uint16_t)
int	ad_getattr (const struct adouble *, uint16_t *)
int	ad_setname (struct adouble *, const char *)
int	ad_setid (struct adouble *, dev_t dev, ino_t ino, uint32_t, uint32_t, const void *)
	save file/folder ID in AppleDoubleV2 netatalk private parameters
uint32_t	ad_getid (struct adouble *, dev_t, ino_t, cnid_t, const void *)
	Retrieve stored file / folder.
uint32_t	ad_forcegetid (struct adouble *adp)
int	ad_readfile_init (const struct adouble *ad, int eid, off_t *off, int end)
ssize_t	ad_recvfile (struct adouble *ad, int eid, int sock, off_t off, size_t len, int)

Detailed Description

Part of Netatalk's AppleDouble implementatation.

Macro Definition Documentation

AD_AFPFILEI_BLANKACCESS

#define AD_AFPFILEI_BLANKACCESS   (1 << 2)

blank access permissions

AD_AFPFILEI_GROUP

#define AD_AFPFILEI_GROUP   (1 << 1)

ignore group

AD_AFPFILEI_OWNER

#define AD_AFPFILEI_OWNER   (1 << 0)

any owner

AD_APPLEDOUBLE_MAGIC

#define AD_APPLEDOUBLE_MAGIC   0x00051607

AD_APPLESINGLE_MAGIC

#define AD_APPLESINGLE_MAGIC   0x00051600

AD_CLOSED

#define AD_CLOSED   0xadc10ced

ad_data_fileno

#define ad_data_fileno

(

ad

)

Value:

((ad)->ad_data_fork.adf_fd)

AD_DATA_OPEN

#define AD_DATA_OPEN

(

ad

)

Value:

(((ad)->ad_data_refcount) && (ad_data_fileno(ad) >= 0))

AD_DATASZ

#define AD_DATASZ   AD_DATASZ2

AD_DATASZ2

#define AD_DATASZ2

Value:

                    (AD_HEADER_LEN + ADEDLEN_NAME + ADEDLEN_COMMENT + ADEDLEN_FILEI + \
                    ADEDLEN_FINDERI + ADEDLEN_DID + ADEDLEN_AFPFILEI + ADEDLEN_SHORTNAME + \
                    ADEDLEN_PRODOSFILEI + ADEDLEN_PRIVDEV + ADEDLEN_PRIVINO + \
                    ADEDLEN_PRIVSYN + ADEDLEN_PRIVID + (ADEID_NUM_V2 * AD_ENTRY_LEN))

AD_DATASZ_EA

#define AD_DATASZ_EA

Value:

                      (AD_HEADER_LEN + (ADEID_NUM_EA * AD_ENTRY_LEN) + \
                      ADEDLEN_FINDERI + ADEDLEN_COMMENT + ADEDLEN_FILEDATESI + ADEDLEN_AFPFILEI + \
                      ADEDLEN_PRIVDEV + ADEDLEN_PRIVINO + ADEDLEN_PRIVSYN + ADEDLEN_PRIVID)

AD_DATASZ_MAX

#define AD_DATASZ_MAX   1024

AD_DATASZ_OSX

#define AD_DATASZ_OSX   (AD_HEADER_LEN + (ADEID_NUM_OSX * AD_ENTRY_LEN) + ADEDLEN_FINDERI)

AD_DATE_ACCESS

#define AD_DATE_ACCESS   12

AD_DATE_BACKUP

#define AD_DATE_BACKUP   8

AD_DATE_CREATE

#define AD_DATE_CREATE   0

AD_DATE_DELTA

#define AD_DATE_DELTA   946684800

AD_DATE_FROM_UNIX

#define AD_DATE_FROM_UNIX

(

x

)

Value:

htonl((x) - AD_DATE_DELTA)

AD_DATE_MASK

#define AD_DATE_MASK

Value:

                              (AD_DATE_CREATE | AD_DATE_MODIFY | \
                              AD_DATE_BACKUP | AD_DATE_ACCESS)

AD_DATE_MODIFY

#define AD_DATE_MODIFY   4

AD_DATE_START

#define AD_DATE_START   htonl(0x80000000)

AD_DATE_TO_UNIX

#define AD_DATE_TO_UNIX

(

x

)

Value:

(ntohl(x) + AD_DATE_DELTA)

AD_DATE_UNIX

#define AD_DATE_UNIX   (1 << 10)

AD_DEV

#define AD_DEV   0x80444556

AD_ENTRY_LEN

#define AD_ENTRY_LEN   12

size of a single entry header

AD_FILELOCK_BASE

#define AD_FILELOCK_BASE   (UINT32_C(0x7FFFFFFF) - 9)

AD_FILELOCK_DENY_RD

#define AD_FILELOCK_DENY_RD   (AD_FILELOCK_BASE + 5)

AD_FILELOCK_DENY_WR

#define AD_FILELOCK_DENY_WR   (AD_FILELOCK_BASE + 4)

AD_FILELOCK_OPEN_NONE

#define AD_FILELOCK_OPEN_NONE   (AD_FILELOCK_BASE + 8)

AD_FILELOCK_OPEN_RD

#define AD_FILELOCK_OPEN_RD   (AD_FILELOCK_BASE + 1)

AD_FILELOCK_OPEN_WR

#define AD_FILELOCK_OPEN_WR   (AD_FILELOCK_BASE + 0)

AD_FILELOCK_RSRC_DENY_RD

#define AD_FILELOCK_RSRC_DENY_RD   (AD_FILELOCK_BASE + 7)

AD_FILELOCK_RSRC_DENY_WR

#define AD_FILELOCK_RSRC_DENY_WR   (AD_FILELOCK_BASE + 6)

AD_FILELOCK_RSRC_OPEN_NONE

#define AD_FILELOCK_RSRC_OPEN_NONE   (AD_FILELOCK_BASE + 9)

AD_FILELOCK_RSRC_OPEN_RD

#define AD_FILELOCK_RSRC_OPEN_RD   (AD_FILELOCK_BASE + 3)

AD_FILELOCK_RSRC_OPEN_WR

#define AD_FILELOCK_RSRC_OPEN_WR   (AD_FILELOCK_BASE + 2)

AD_FILLER_NETATALK

#define AD_FILLER_NETATALK   "Netatalk "

AD_FILLER_OSX

#define AD_FILLER_OSX   "Mac OS X"

ad_get_MD_flags

#define ad_get_MD_flags

(

ad

)

Value:

((ad)->ad_mdp->adf_flags)

ad_get_RF_flags

#define ad_get_RF_flags

(

ad

)

Value:

((ad)->ad_rfp->adf_flags)

ad_get_syml_opt

#define ad_get_syml_opt

(

ad

)

Value:

(((ad)->ad_options & ADVOL_FOLLO_SYML) ? 0 : O_NOFOLLOW)

ad_getentrylen

#define ad_getentrylen	(		ad,
			eid )

Value:

((ad)->ad_eid[(eid)].ade_len)

ad_getversion

#define ad_getversion

(

ad

)

Value:

((ad)->ad_version)

AD_HEADER_LEN

#define AD_HEADER_LEN   (ADEDLEN_MAGIC + ADEDLEN_VERSION + ADEDLEN_FILLER + ADEDLEN_NENTRIES)

26

AD_ID

#define AD_ID   0x8053567E

AD_INITED

#define AD_INITED   0xad494e54

ad"INT"

AD_INO

#define AD_INO   0x80494E4F

AD_MAGIC

#define AD_MAGIC   AD_APPLEDOUBLE_MAGIC

ad_meta_fileno

#define ad_meta_fileno

(

ad

)

Value:

((ad)->ad_mdp->adf_fd)

AD_META_OPEN

#define AD_META_OPEN

(

ad

)

Value:

(((ad)->ad_meta_refcount) && (ad_meta_fileno(ad) >= 0))

ad_ref

#define ad_ref

(

ad

)

Value:

(ad)->ad_refcount++

ad_reso_fileno

#define ad_reso_fileno

(

ad

)

Value:

((ad)->ad_rfp->adf_fd)

AD_RSRC_OPEN

#define AD_RSRC_OPEN

(

ad

)

Value:

(((ad)->ad_reso_refcount) && (ad_reso_fileno(ad) >= 0))

ad_setentrylen

#define ad_setentrylen	(		ad,
			eid,
			len )

Value:

((ad)->ad_eid[(eid)].ade_len = (len))

ad_setentryoff

#define ad_setentryoff	(		ad,
			eid,
			off )

Value:

((ad)->ad_eid[(eid)].ade_off = (off))

AD_SYMLINK

#define AD_SYMLINK   -2

special fd value used to indicate an open fork file is a (not open) symlink

AD_SYN

#define AD_SYN   0x8053594E

ad_unref

#define ad_unref

(

ad

)

Value:

--((ad)->ad_refcount)

AD_VERSION

#define AD_VERSION   AD_VERSION_EA

AD_VERSION2

#define AD_VERSION2   0x00020000

AD_VERSION_EA

#define AD_VERSION_EA   0x00020002

ADEDLEN_AFPFILEI

#define ADEDLEN_AFPFILEI   4

ADEDLEN_COMMENT

#define ADEDLEN_COMMENT   200

ADEDLEN_DID

#define ADEDLEN_DID   4

ADEDLEN_FILEDATESI

#define ADEDLEN_FILEDATESI   16

ADEDLEN_FILEI

#define ADEDLEN_FILEI   16

ADEDLEN_FILLER

#define ADEDLEN_FILLER   16

ADEDLEN_FINDERI

#define ADEDLEN_FINDERI   32

ADEDLEN_ICONBW

#define ADEDLEN_ICONBW   128

ADEDLEN_ICONCOL

#define ADEDLEN_ICONCOL   1024

ADEDLEN_MACFILEI

#define ADEDLEN_MACFILEI   4

ADEDLEN_MAGIC

#define ADEDLEN_MAGIC   4

ADEDLEN_MSDOSFILEI

#define ADEDLEN_MSDOSFILEI   2

ADEDLEN_NAME

#define ADEDLEN_NAME   255

ADEDLEN_NENTRIES

#define ADEDLEN_NENTRIES   2

ADEDLEN_PRIVDEV

#define ADEDLEN_PRIVDEV   8

ADEDLEN_PRIVID

#define ADEDLEN_PRIVID   4

ADEDLEN_PRIVINO

#define ADEDLEN_PRIVINO   8

ADEDLEN_PRIVSYN

#define ADEDLEN_PRIVSYN   8

ADEDLEN_PRODOSFILEI

#define ADEDLEN_PRODOSFILEI   8

ADEDLEN_SHORTNAME

#define ADEDLEN_SHORTNAME   12

length up to 8.3

ADEDLEN_VERSION

#define ADEDLEN_VERSION   4

ADEDOFF_FINDERI_OSX

#define ADEDOFF_FINDERI_OSX   (AD_HEADER_LEN + ADEID_NUM_OSX*AD_ENTRY_LEN)

ADEDOFF_RFORK_OSX

#define ADEDOFF_RFORK_OSX   (ADEDOFF_FINDERI_OSX + ADEDLEN_FINDERI)

ADEID_AFPFILEI

#define ADEID_AFPFILEI   14

where the rest of the FILEI info goes

ADEID_COMMENT

#define ADEID_COMMENT   4

ADEID_DFORK

#define ADEID_DFORK   1

ADEID_DID

#define ADEID_DID   15

ADEID_FILEDATESI

#define ADEID_FILEDATESI   8

ADEID_FILEI

#define ADEID_FILEI   7

v1, replaced by ADEID_FILEDATESI

ADEID_FINDERI

#define ADEID_FINDERI   9

ADEID_ICONBW

#define ADEID_ICONBW   5

ADEID_ICONCOL

#define ADEID_ICONCOL   6

ADEID_MACFILEI

#define ADEID_MACFILEI   10

we don't use this

ADEID_MAX

#define ADEID_MAX   (ADEID_PRIVID + 1)

ADEID_MSDOSFILEI

#define ADEID_MSDOSFILEI   12

we don't use this

ADEID_NAME

#define ADEID_NAME   3

ADEID_NUM_EA

#define ADEID_NUM_EA   8

ADEID_NUM_OSX

#define ADEID_NUM_OSX   2

ADEID_NUM_V2

#define ADEID_NUM_V2   13

ADEID_PRIVDEV

#define ADEID_PRIVDEV   16

ADEID_PRIVID

#define ADEID_PRIVID   19

ADEID_PRIVINO

#define ADEID_PRIVINO   17

ADEID_PRIVSYN

#define ADEID_PRIVSYN   18

in synch with database

ADEID_PRODOSFILEI

#define ADEID_PRODOSFILEI   11

we store prodos info here

ADEID_RFORK

#define ADEID_RFORK   2

ADEID_SHORTNAME

#define ADEID_SHORTNAME   13

ADFLAGS_CHECK_OF

#define ADFLAGS_CHECK_OF   (1<<6)

check for open forks from us and other afpd's

ADFLAGS_CREATE

#define ADFLAGS_CREATE   (1<<10)

create file, open called with O_CREAT

ADFLAGS_DF

#define ADFLAGS_DF   (1<<0)

ADFLAGS_DIR

#define ADFLAGS_DIR   (1<<3)

ADFLAGS_EXCL

#define ADFLAGS_EXCL   (1<<11)

exclusive open, open called with O_EXCL

ADFLAGS_HF

#define ADFLAGS_HF   (1<<2)

ADFLAGS_NOHF

#define ADFLAGS_NOHF   (1<<4)

not an error if no metadata fork

ADFLAGS_NORF

#define ADFLAGS_NORF   (1<<5)

not an error if no resource fork

ADFLAGS_RDONLY

#define ADFLAGS_RDONLY   (1<<9)

open read only

ADFLAGS_RDWR

#define ADFLAGS_RDWR   (1<<8)

open read/write

ADFLAGS_RF

#define ADFLAGS_RF   (1<<1)

ADFLAGS_SETSHRMD

#define ADFLAGS_SETSHRMD   (1<<7)

setting share mode must be done with excl fcnt lock, which implies that the file must be opened rw. If it can't be opened rw (eg EPERM or EROFS) it will be opened ro and the fcntl locks will be shared, that at least prevent other users who have rw access to the file from placing excl locks.

ADFLAGS_TRUNC

#define ADFLAGS_TRUNC   (1<<12)

truncate, open called with O_TRUNC

ADLOCK_CLR

#define ADLOCK_CLR   (0)

ADLOCK_FILELOCK

#define ADLOCK_FILELOCK   (1<<3)

ADLOCK_MASK

#define ADLOCK_MASK   (ADLOCK_RD | ADLOCK_WR)

ADLOCK_RD

#define ADLOCK_RD   (1<<0)

ADLOCK_UPGRADE

#define ADLOCK_UPGRADE   (1<<2)

ADLOCK_WR

#define ADLOCK_WR   (1<<1)

ADVOL_FOLLO_SYML

#define ADVOL_FOLLO_SYML   (1 << 4)

ADVOL_FORCE_STICKY_XATTR

#define ADVOL_FORCE_STICKY_XATTR   (1 << 5)

ADVOL_INVDOTS

#define ADVOL_INVDOTS   (1 << 3)

dot files (.DS_Store) are invisible)

ADVOL_NODEV

#define ADVOL_NODEV   (1 << 0)

ADVOL_RO

#define ADVOL_RO   (1 << 1)

ADVOL_UNIXPRIV

#define ADVOL_UNIXPRIV   (1 << 2)

adouble unix priv

ATTRBIT_BACKUP

#define ATTRBIT_BACKUP   (1<<6)

"p", fd

ATTRBIT_DOPEN

#define ATTRBIT_DOPEN   (1<<3)

data fork already open. Not stored, computed on the fly

ATTRBIT_EXPFLDR

#define ATTRBIT_EXPFLDR   (1<<1)

Folder is a sharepoint

ATTRBIT_INVISIBLE

#define ATTRBIT_INVISIBLE   (1<<0)

opaque from FinderInfo

ATTRBIT_MOUNTED

#define ATTRBIT_MOUNTED   (1<<3)

Directory is mounted by a user

ATTRBIT_MULTIUSER

#define ATTRBIT_MULTIUSER   (1<<1)

file: opaque, dir: see below

ATTRBIT_NOCOPY

#define ATTRBIT_NOCOPY   (1<<10)

"o", f

ATTRBIT_NODELETE

#define ATTRBIT_NODELETE   (1<<8)

"l", fd

ATTRBIT_NORENAME

#define ATTRBIT_NORENAME   (1<<7)

"r", fd

ATTRBIT_NOWRITE

#define ATTRBIT_NOWRITE   (1<<5)

"w", f, write inhibit(v2)/read-only(v1) bit

ATTRBIT_ROPEN

#define ATTRBIT_ROPEN   (1<<4)

resource fork already open. Not stored, computed on the fly

ATTRBIT_SETCLR

#define ATTRBIT_SETCLR   (1<<15)

set/clear bit (d)

ATTRBIT_SHARED

#define ATTRBIT_SHARED   (1<<4)

Shared area, called IsExpFolder in spec

ATTRBIT_SYSTEM

#define ATTRBIT_SYSTEM   (1<<2)

"y", fd

BYTELOCK_MAX

#define BYTELOCK_MAX   (AD_FILELOCK_BASE - 1)

FINDERINFO_CLOSEDVIEW

#define FINDERINFO_CLOSEDVIEW   0x100

FINDERINFO_COLOR

#define FINDERINFO_COLOR   (0x0e)

FINDERINFO_CUSTOMICON

#define FINDERINFO_CUSTOMICON   0x4

FINDERINFO_FRCREATOFF

#define FINDERINFO_FRCREATOFF   4

FINDERINFO_FRFLAGOFF

#define FINDERINFO_FRFLAGOFF   8

FINDERINFO_FRTYPEOFF

#define FINDERINFO_FRTYPEOFF   0

FINDERINFO_FRVIEWOFF

#define FINDERINFO_FRVIEWOFF   14

FINDERINFO_HASBEENINITED

#define FINDERINFO_HASBEENINITED   (1<<8)

"i", fd

FINDERINFO_HASBUNDLE

#define FINDERINFO_HASBUNDLE   (1<<13)

"b", fd

FINDERINFO_HASCUSTOMICON

#define FINDERINFO_HASCUSTOMICON   (1<<10)

"c", fd

FINDERINFO_HASNOINITS

#define FINDERINFO_HASNOINITS   (1<<7)

"n", f

FINDERINFO_HIDEEXT

#define FINDERINFO_HIDEEXT   (1<<4)

"e", fd

FINDERINFO_INVISIBLE

#define FINDERINFO_INVISIBLE   (1<<14)

"v", fd

FINDERINFO_ISALIAS

#define FINDERINFO_ISALIAS   (1<<15)

"a", fd

FINDERINFO_ISHARED

#define FINDERINFO_ISHARED   (1<<6)

"m", f

FINDERINFO_ISONDESK

#define FINDERINFO_ISONDESK   (1)

"d", fd

FINDERINFO_ISSTATIONNERY

#define FINDERINFO_ISSTATIONNERY   (1<<11)

"t", f

FINDERINFO_NAMELOCKED

#define FINDERINFO_NAMELOCKED   (1<<12)

"s", fd

Typedef Documentation

adf_lock_t

typedef struct adf_lock_t adf_lock_t

cnid_t

typedef uint32_t cnid_t

Function Documentation

ad_close()

int ad_close ( struct adouble * ad, int adflags )

extern

Close a struct adouble freeing all resources

ad_convert()

int ad_convert ( const char * path, const struct stat * sp, const struct vol * vol, const char ** newpath )

extern

AppleDouble and encoding conversion on the fly.

Parameters

[in]	path	path to file or directory
[in]	sp	stat(path)
[in]	vol	volume handle
[out]	newpath	if encoding changed, new name. Can be NULL.

Returns

-1 on internal error, otherwise 0. newpath is NULL if no character conversion was done, otherwise newpath points to a static string with the converted name

ad_copy_header()

int ad_copy_header ( struct adouble * add, struct adouble * ads )

extern

ad_dir()

char * ad_dir ( const char * path )

extern

Support inherited protection modes for AppleDouble files. The supplied mode is ANDed with the parent directory's mask value in lieu of "umask", and that value is returned.

ad_dtruncate()

int ad_dtruncate ( struct adouble * ad, off_t size )

extern

ad_entry()

void * ad_entry ( const struct adouble * ad, int eid )

extern

ad_flush()

int ad_flush ( struct adouble * ad )

extern

ad_forcegetid()

uint32_t ad_forcegetid ( struct adouble * adp )

extern

ad_getattr()

int ad_getattr ( const struct adouble * ad, uint16_t * attr )

extern

Note

the "shared" and "invisible" attributes are opaque and stored and retrieved from the FinderFlags. This fixes Bug #2802236:

See also

https://sourceforge.net/p/netatalk/bugs/350/

ad_getdate()

int ad_getdate ( const struct adouble * ad, unsigned int dateoff, uint32_t * date )

extern

ad_getentryoff()

off_t ad_getentryoff ( const struct adouble * ad, int eid )

extern

ad_getfuid()

uid_t ad_getfuid ( void )

extern

ad_getid()

uint32_t ad_getid ( struct adouble * adp, const dev_t st_dev, const ino_t st_ino, const cnid_t did, const void * stamp )

extern

Retrieve stored file / folder.

Note

Callers should treat a return of CNID_INVALID (0) as an invalid value.

ad_hf_mode()

mode_t ad_hf_mode ( mode_t mode )

extern

build a resource fork mode from the data fork mode: remove X mode and extend header to RW if R or W (W if R for locking),

ad_init()

void ad_init ( struct adouble * ad, const struct vol * vol )

extern

ad_init_offsets()

int ad_init_offsets ( struct adouble * ad )

extern

Initialize offset pointers

ad_init_old()

void ad_init_old ( struct adouble * ad, int flags, int options )

extern

ad_lock()

int ad_lock ( struct adouble * ad, uint32_t eid, int type, off_t off, off_t len, int fork )

extern

ad_metadata()

int ad_metadata ( const char * name, int flags, struct adouble * adp )

extern

open metadata, possibly as root

Return only metadata but try very hard i.e. at first try as user, then try as root.

Parameters

name	name of file/dir
flags	ADFLAGS_DIR: name is a directory ADFLAGS_CHECK_OF: test if name is open by us or another afpd process
adp	pointer to struct adouble

ad_metadataat()

int ad_metadataat ( int dirfd, const char * name, int flags, struct adouble * adp )

extern

openat like wrapper for ad_metadata

ad_mkdir()

int ad_mkdir ( const char * path, mode_t mode )

extern

Use mkdir() with mode bits taken from ad_mode().

ad_mode()

int ad_mode ( const char * path, mode_t mode )

extern

return access right of path parent directory

ad_open()

int ad_open ( struct adouble * ad, const char * path, int adflags, ... )

extern

Open data-, metadata(header)- or resource fork.

ad_open(struct adouble *ad, const char *path, int adflags, int flags)
ad_open(struct adouble *ad, const char *path, int adflags, int flags, mode_t mode)

You must call ad_init() before ad_open, usually you'll just call it like this:

struct adoube ad;
ad_init(&ad, vol->v_adouble, vol->v_ad_options);

Open a files data fork, metadata fork or resource fork.

Parameters

[in,out]	ad	pointer to struct adouble
[in]	path	Path to file or directory
[in]	adflags	Flags specifying which fork to open, can be or'd (see below)
[in]	...	mode used with O_CREATE

Regular adflags:

• ADFLAGS_DF: open data fork
• ADFLAGS_RF: open resource fork
• ADFLAGS_HF: open header (metadata) file
• ADFLAGS_NOHF: it's not an error if header file couldn't be opened
• ADFLAGS_NORF: it's not an error if reso fork couldn't be opened
• ADFLAGS_DIR: if path is a directory you MUST or ADFLAGS_DIR to adflags

Access mode for the forks:

• ADFLAGS_RDONLY: open read only
• ADFLAGS_RDWR: open read write

Creation flags:

• ADFLAGS_CREATE: create if not existing
• ADFLAGS_TRUNC: truncate

Special flags:

• ADFLAGS_CHECK_OF: check for open forks from us and other afpd's
• ADFLAGS_SETSHRMD: this adouble struct will be used to set sharemode locks. This basically results in the files being opened RW instead of RDONLY.

The open mode flags (rw vs ro) have to take into account all the following requirements:

• we remember open fds for files because me must avoid a single close releasing fcntl locks for other fds of the same file

  Bug

  on Solaris (HAVE_EAFD) ADFLAGS_RF doesn't work without ADFLAGS_HF, because it checks whether ad_meta_fileno() is already opened. As a workaround pass ADFLAGS_SETSHRMD.

Returns

0 on success, any other value indicates an error

ad_openat()

int ad_openat ( struct adouble * ad, int dirfd, const char * path, int adflags, ... )

extern

ad_openforks()

uint16_t ad_openforks ( struct adouble * ad, uint16_t attrbits )

extern

Return if a file is open by another process.

Optimized for the common case:

• there's no locks held by another process (clients)
• or we already know the answer and don't need to test (attrbits)

Parameters

[in,out]	ad	handle
[in]	attrbits	forks opened by us

Returns

bitflags ATTRBIT_DOPEN | ATTRBIT_ROPEN if other process has fork of file opened

ad_path()

const char * ad_path ( const char * path, int adflags )

extern

Put the .AppleDouble where it needs to be:

    /   a/.AppleDouble/b
a/b
    \   b/.AppleDouble/.Parent

Bug

should do something for pathname > MAXPATHLEN

ad_path_ea()

const char * ad_path_ea ( const char * path, int adflags )

extern

ad_path_osx()

const char * ad_path_osx ( const char * path, int adflags )

extern

ad_pread()

ssize_t ad_pread ( struct ad_fd * , void * , size_t , off_t  )

extern

ad_read()

ssize_t ad_read ( struct adouble * ad, uint32_t eid, off_t off, char * buf, size_t buflen )

extern

ad_readfile_init()

int ad_readfile_init ( const struct adouble * ad, int eid, off_t * off, int end )

extern

ad_rebuild_adouble_header_ea()

int ad_rebuild_adouble_header_ea ( struct adouble * ad )

extern

ad_rebuild_adouble_header_osx()

int ad_rebuild_adouble_header_osx ( struct adouble * ad, char * adbuf )

extern

Prepare adbuf buffer from struct adouble for writing on disk

ad_rebuild_adouble_header_v2()

int ad_rebuild_adouble_header_v2 ( struct adouble * ad )

extern

Prepare ad->ad_data buffer from struct adouble for writing on disk

ad_recvfile()

ssize_t ad_recvfile ( struct adouble * ad, int eid, int sock, off_t off, size_t len, int splice_size )

extern

read from a socket and write to an adouble file

ad_refresh()

int ad_refresh ( const char * path, struct adouble * ad )

extern

ad_reso_size()

off_t ad_reso_size ( const char * path, int adflags, struct adouble * ad )

extern

Get resofork length for adouble:ea, parameter 'ad' may be NULL

ad_rtruncate()

int ad_rtruncate ( struct adouble * ad, const char * uname, off_t size )

extern

ad_setattr()

int ad_setattr ( const struct adouble * ad, const uint16_t attribute )

extern

ad_setdate()

int ad_setdate ( struct adouble * ad, unsigned int dateoff, uint32_t date )

extern

ad_setfuid()

int ad_setfuid ( const uid_t id )

extern

ad_setid()

int ad_setid ( struct adouble * adp, const dev_t dev, const ino_t ino, const uint32_t id, const cnid_t did, const void * stamp )

extern

save file/folder ID in AppleDoubleV2 netatalk private parameters

Returns

1 if resource fork has been modified

-1 on error.

ad_setname()

int ad_setname ( struct adouble * ad, const char * path )

extern

set resource fork filename attribute.

ad_size()

off_t ad_size ( const struct adouble * ad, uint32_t eid )

extern

ad_stat()

int ad_stat ( const char * path, struct stat * stbuf )

extern

stat path parent directory

ad_testlock()

int ad_testlock ( struct adouble * ad, int eid, const off_t off )

extern

Test for a share mode lock.

Parameters

[in,out]	ad	handle
[in]	eid	datafork or resource fork
[in]	off	sharemode lock to test

Returns

1 if there's an existing lock, 0 if there's no lock, -1 in case any error occured

ad_tmplock()

int ad_tmplock ( struct adouble * ad, uint32_t eid, int type, off_t off, off_t len, int fork )

extern

ad_unlock()

void ad_unlock ( struct adouble * ad, int fork, int unlckbrl )

extern

ad_valid_header_osx()

int ad_valid_header_osx ( const char * path )

extern

ad_write()

ssize_t ad_write ( struct adouble * ad, uint32_t eid, off_t off, int end, const char * buf, size_t buflen )

extern

adf_pread()

ssize_t adf_pread ( struct ad_fd * ad_fd, void * buf, size_t count, off_t offset )

extern

adf_pwrite()

ssize_t adf_pwrite ( struct ad_fd * ad_fd, const void * buf, size_t count, off_t offset )

extern

adflags2logstr()

const char * adflags2logstr ( int adflags )

extern

copy_fork()

int copy_fork ( int eid, struct adouble * add, struct adouble * ads, uint8_t * buf, size_t buflen )

extern

copy only the fork data stream

fsetrsrcea()

int fsetrsrcea ( struct adouble * ad, int fd, const char * eaname, const void * value, size_t size, int flags )

extern

sys_ftruncate()

int sys_ftruncate ( int fd, off_t length )

extern