ad_open.c File Reference

#include <arpa/inet.h>
#include <errno.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <sys/param.h>
#include <atalk/adouble.h>
#include <atalk/compat.h>
#include <atalk/ea.h>
#include <atalk/errchk.h>
#include <atalk/logger.h>
#include <atalk/unix.h>
#include <atalk/util.h>
#include <atalk/volume.h>
#include "ad_lock.h"

Data Structures
struct	entry

Macros
#define	ADEDOFF_MAGIC   (0)
#define	ADEDOFF_VERSION   (ADEDOFF_MAGIC + ADEDLEN_MAGIC)
#define	ADEDOFF_FILLER   (ADEDOFF_VERSION + ADEDLEN_VERSION)
#define	ADEDOFF_NENTRIES   (ADEDOFF_FILLER + ADEDLEN_FILLER)
#define	ADEDLEN_INIT   0
#define	ADEDOFF_NAME_V2   (AD_HEADER_LEN + ADEID_NUM_V2*AD_ENTRY_LEN)
#define	ADEDOFF_COMMENT_V2   (ADEDOFF_NAME_V2 + ADEDLEN_NAME)
#define	ADEDOFF_FILEDATESI   (ADEDOFF_COMMENT_V2 + ADEDLEN_COMMENT)
#define	ADEDOFF_FINDERI_V2   (ADEDOFF_FILEDATESI + ADEDLEN_FILEDATESI)
#define	ADEDOFF_DID   (ADEDOFF_FINDERI_V2 + ADEDLEN_FINDERI)
#define	ADEDOFF_AFPFILEI   (ADEDOFF_DID + ADEDLEN_DID)
#define	ADEDOFF_SHORTNAME   (ADEDOFF_AFPFILEI + ADEDLEN_AFPFILEI)
#define	ADEDOFF_PRODOSFILEI   (ADEDOFF_SHORTNAME + ADEDLEN_SHORTNAME)
#define	ADEDOFF_PRIVDEV   (ADEDOFF_PRODOSFILEI + ADEDLEN_PRODOSFILEI)
#define	ADEDOFF_PRIVINO   (ADEDOFF_PRIVDEV + ADEDLEN_PRIVDEV)
#define	ADEDOFF_PRIVSYN   (ADEDOFF_PRIVINO + ADEDLEN_PRIVINO)
#define	ADEDOFF_PRIVID   (ADEDOFF_PRIVSYN + ADEDLEN_PRIVSYN)
#define	ADEDOFF_RFORK_V2   (ADEDOFF_PRIVID + ADEDLEN_PRIVID)
#define	ADEDOFF_FINDERI_EA   (AD_HEADER_LEN + ADEID_NUM_EA * AD_ENTRY_LEN)
#define	ADEDOFF_COMMENT_EA   (ADEDOFF_FINDERI_EA + ADEDLEN_FINDERI)
#define	ADEDOFF_FILEDATESI_EA   (ADEDOFF_COMMENT_EA + ADEDLEN_COMMENT)
#define	ADEDOFF_AFPFILEI_EA   (ADEDOFF_FILEDATESI_EA + ADEDLEN_FILEDATESI)
#define	ADEDOFF_PRIVDEV_EA   (ADEDOFF_AFPFILEI_EA + ADEDLEN_AFPFILEI)
#define	ADEDOFF_PRIVINO_EA   (ADEDOFF_PRIVDEV_EA + ADEDLEN_PRIVDEV)
#define	ADEDOFF_PRIVSYN_EA   (ADEDOFF_PRIVINO_EA + ADEDLEN_PRIVINO)
#define	ADEDOFF_PRIVID_EA   (ADEDOFF_PRIVSYN_EA + ADEDLEN_PRIVSYN)
#define	TIMEWARP_DELTA   157680000
#define	ADFLAGS2LOGSTRBUFSIZ   128
#define	OPENFLAGS2LOGSTRBUFSIZ   128
#define	EMULATE_SUIDDIR
#define	DEFMASK   07700 /* be conservative */

Functions
static int	ad_mkrf (const char *path)
static int	ad_header_read (const char *path, struct adouble *ad, const struct stat *hst)
static int	ad_header_upgrade (struct adouble *ad, const char *name)
static int	ad_header_read_ea (const char *path, struct adouble *ad, const struct stat *hst)
static int	ad_header_upgrade_ea (struct adouble *ad, const char *name)
off_t	ad_reso_size (const char *path, int adflags, struct adouble *ad)
static int	ad_mkrf_osx (const char *path)
const char *	adflags2logstr (int adflags)
const char *	openflags2logstr (int oflags)
static uint32_t	get_eid (uint32_t eid)
int	ad_init_offsets (struct adouble *ad)
static int	new_ad_header (struct adouble *ad, const char *path, struct stat *stp, int adflags)
static int	parse_entries (struct adouble *ad, uint16_t nentries, size_t valid_data_len)
int	ad_valid_header_osx (const char *path)
static int	ad_convert_osx (const char *path, struct adouble *ad)
static int	ad_header_read_osx (const char *path, struct adouble *ad, struct stat *hst)
static int	ad_header_read_ea (const char *path, struct adouble *ad, const struct stat *hst _U_)
static int	ad_mkrf_osx (const char *path _U_)
static int	ad_chown (const char *path, struct stat *stbuf)
static int	ad_mode_st (const char *path, mode_t *mode, struct stat *stbuf)
static int	ad_header_upgrade (struct adouble *ad _U_, const char *name _U_)
static int	ad_header_upgrade_ea (struct adouble *ad _U_, const char *name _U_)
static int	ad_error (struct adouble *ad, int adflags)
static int	ad2openflags (const struct adouble *ad, int adfile, int adflags)
static int	ad_open_df (const char *path, int adflags, mode_t mode, struct adouble *ad)
static int	ad_open_hf_v2 (const char *path, int adflags, mode_t mode, struct adouble *ad)
static int	ad_open_hf_ea (const char *path, int adflags, int mode _U_, struct adouble *ad)
static int	ad_open_hf (const char *path, int adflags, int mode, struct adouble *ad)
off_t	ad_reso_size (const char *path, int adflags, struct adouble *ad _U_)
static int	ad_open_rf_v2 (const char *path, int adflags, int mode _U_, struct adouble *ad)
static int	ad_open_rf_ea (const char *path, int adflags, int mode, struct adouble *ad)
static int	ad_open_rf (const char *path, int adflags, int mode, struct adouble *ad)
static bool	ad_entry_check_size (uint32_t eid, size_t bufsize, uint32_t off, uint32_t got_len)
void *	ad_entry (const struct adouble *ad, int eid)
off_t	ad_getentryoff (const struct adouble *ad, int eid)
const char *	ad_path_ea (const char *path, int adflags _U_)
const char *	ad_path_osx (const char *path, int adflags _U_)
const char *	ad_path (const char *path, int adflags)
char *	ad_dir (const char *path)
int	ad_setfuid (const uid_t id)
uid_t	ad_getfuid (void)
int	ad_stat (const char *path, struct stat *stbuf)
int	ad_mode (const char *path, mode_t mode)
int	ad_mkdir (const char *path, mode_t mode)
static void	ad_init_func (struct adouble *ad)
void	ad_init_old (struct adouble *ad, int flags, int options)
void	ad_init (struct adouble *ad, const struct vol *restrict vol)
int	ad_open (struct adouble *ad, const char *path, int adflags,...)
int	ad_metadata (const char *name, int flags, struct adouble *adp)
	open metadata, possibly as root
int	ad_metadataat (int dirfd, const char *name, int flags, struct adouble *adp)
int	ad_refresh (const char *path, struct adouble *ad)
int	ad_openat (struct adouble *ad, int dirfd, const char *path, int adflags,...)
mode_t	ad_hf_mode (mode_t mode)

Variables
static uid_t	default_uid = -1
static struct adouble_fops	ad_adouble
static struct adouble_fops	ad_adouble_ea
static const struct entry	entry_order2 [ADEID_NUM_V2+1]
static const struct entry	entry_order_ea [ADEID_NUM_EA+1]

Detailed Description

Part of Netatalk's AppleDouble implementatation

See also

include/atalk/adouble.h

Macro Definition Documentation

ADEDLEN_INIT

#define ADEDLEN_INIT   0

ADEDOFF_AFPFILEI

#define ADEDOFF_AFPFILEI   (ADEDOFF_DID + ADEDLEN_DID)

ADEDOFF_AFPFILEI_EA

#define ADEDOFF_AFPFILEI_EA   (ADEDOFF_FILEDATESI_EA + ADEDLEN_FILEDATESI)

ADEDOFF_COMMENT_EA

#define ADEDOFF_COMMENT_EA   (ADEDOFF_FINDERI_EA + ADEDLEN_FINDERI)

ADEDOFF_COMMENT_V2

#define ADEDOFF_COMMENT_V2   (ADEDOFF_NAME_V2 + ADEDLEN_NAME)

ADEDOFF_DID

#define ADEDOFF_DID   (ADEDOFF_FINDERI_V2 + ADEDLEN_FINDERI)

ADEDOFF_FILEDATESI

#define ADEDOFF_FILEDATESI   (ADEDOFF_COMMENT_V2 + ADEDLEN_COMMENT)

ADEDOFF_FILEDATESI_EA

#define ADEDOFF_FILEDATESI_EA   (ADEDOFF_COMMENT_EA + ADEDLEN_COMMENT)

ADEDOFF_FILLER

#define ADEDOFF_FILLER   (ADEDOFF_VERSION + ADEDLEN_VERSION)

ADEDOFF_FINDERI_EA

#define ADEDOFF_FINDERI_EA   (AD_HEADER_LEN + ADEID_NUM_EA * AD_ENTRY_LEN)

ADEDOFF_FINDERI_V2

#define ADEDOFF_FINDERI_V2   (ADEDOFF_FILEDATESI + ADEDLEN_FILEDATESI)

ADEDOFF_MAGIC

#define ADEDOFF_MAGIC   (0)

ADEDOFF_NAME_V2

#define ADEDOFF_NAME_V2   (AD_HEADER_LEN + ADEID_NUM_V2*AD_ENTRY_LEN)

ADEDOFF_NENTRIES

#define ADEDOFF_NENTRIES   (ADEDOFF_FILLER + ADEDLEN_FILLER)

ADEDOFF_PRIVDEV

#define ADEDOFF_PRIVDEV   (ADEDOFF_PRODOSFILEI + ADEDLEN_PRODOSFILEI)

ADEDOFF_PRIVDEV_EA

#define ADEDOFF_PRIVDEV_EA   (ADEDOFF_AFPFILEI_EA + ADEDLEN_AFPFILEI)

ADEDOFF_PRIVID

#define ADEDOFF_PRIVID   (ADEDOFF_PRIVSYN + ADEDLEN_PRIVSYN)

ADEDOFF_PRIVID_EA

#define ADEDOFF_PRIVID_EA   (ADEDOFF_PRIVSYN_EA + ADEDLEN_PRIVSYN)

ADEDOFF_PRIVINO

#define ADEDOFF_PRIVINO   (ADEDOFF_PRIVDEV + ADEDLEN_PRIVDEV)

ADEDOFF_PRIVINO_EA

#define ADEDOFF_PRIVINO_EA   (ADEDOFF_PRIVDEV_EA + ADEDLEN_PRIVDEV)

ADEDOFF_PRIVSYN

#define ADEDOFF_PRIVSYN   (ADEDOFF_PRIVINO + ADEDLEN_PRIVINO)

ADEDOFF_PRIVSYN_EA

#define ADEDOFF_PRIVSYN_EA   (ADEDOFF_PRIVINO_EA + ADEDLEN_PRIVINO)

ADEDOFF_PRODOSFILEI

#define ADEDOFF_PRODOSFILEI   (ADEDOFF_SHORTNAME + ADEDLEN_SHORTNAME)

ADEDOFF_RFORK_V2

#define ADEDOFF_RFORK_V2   (ADEDOFF_PRIVID + ADEDLEN_PRIVID)

ADEDOFF_SHORTNAME

#define ADEDOFF_SHORTNAME   (ADEDOFF_AFPFILEI + ADEDLEN_AFPFILEI)

ADEDOFF_VERSION

#define ADEDOFF_VERSION   (ADEDOFF_MAGIC + ADEDLEN_MAGIC)

ADFLAGS2LOGSTRBUFSIZ

#define ADFLAGS2LOGSTRBUFSIZ   128

DEFMASK

#define DEFMASK   07700 /* be conservative */

EMULATE_SUIDDIR

#define EMULATE_SUIDDIR

OPENFLAGS2LOGSTRBUFSIZ

#define OPENFLAGS2LOGSTRBUFSIZ   128

TIMEWARP_DELTA

#define TIMEWARP_DELTA   157680000

Function Documentation

ad2openflags()

int ad2openflags ( const struct adouble * ad, int adfile, int adflags )

static

Map ADFLAGS to open() flags

Parameters

ad	(r) the adouble structure
adfile	(r) the file you really want to open: ADFLAGS_DF or ADFLAGS_HF
adflags	(r) flags from ad_open(..., adflags, ...)

Returns

mapped flags suitable for calling open()

ad_chown()

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

static

ad_convert_osx()

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

static

Convert from Apple's ._ file to Netatalk

Apple's AppleDouble may contain a FinderInfo entry longer then 32 bytes containing packed xattrs. Netatalk can't deal with that, so we simply discard the packed xattrs.

As we call ad_open() which might result in a recursion, just to be sure use static variable in_conversion to check for that.

Returns -1 in case an error occured, 0 if no conversion was done, 1 otherwise

ad_dir()

char * ad_dir

(

const char *

path

)

ad_entry()

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

ad_entry_check_size()

bool ad_entry_check_size ( uint32_t eid, size_t bufsize, uint32_t off, uint32_t got_len )

static

ad_error()

int ad_error ( struct adouble * ad, int adflags )

static

Error handling for adouble header(=metadata) file open error

We're called because opening ADFLAGS_HF caused an error.

1. In case ad_open is called with ADFLAGS_NOHF the error is suppressed.
2. Open non-existent resource fork, this will just result in first read return EOF
3. If ad_open was called with ADFLAGS_DF we may have opened the datafork and thus ought to close it before returning with an error condition.

ad_getentryoff()

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

ad_getfuid()

uid_t ad_getfuid

(

void

)

ad_header_read()

int ad_header_read ( const char * path, struct adouble * ad, const struct stat * hst )

static

ad_header_read_ea() [1/2]

int ad_header_read_ea ( const char * path, struct adouble * ad, const struct stat *hst _U_ )

static

ad_header_read_ea() [2/2]

int ad_header_read_ea ( const char * path, struct adouble * ad, const struct stat * hst )

static

ad_header_read_osx()

int ad_header_read_osx ( const char * path, struct adouble * ad, struct stat * hst )

static

ad_header_upgrade() [1/2]

int ad_header_upgrade ( struct adouble *ad _U_, const char *name _U_ )

static

ad_header_upgrade() [2/2]

int ad_header_upgrade ( struct adouble * ad, const char * name )

static

ad_header_upgrade_ea() [1/2]

int ad_header_upgrade_ea ( struct adouble *ad _U_, const char *name _U_ )

static

ad_header_upgrade_ea() [2/2]

int ad_header_upgrade_ea ( struct adouble * ad, const char * name )

static

ad_hf_mode()

mode_t ad_hf_mode

(

mode_t

mode

)

ad_init()

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

ad_init_func()

void ad_init_func ( struct adouble * ad )

static

ad_init_offsets()

int ad_init_offsets

(

struct adouble *

ad

)

Initialize offset pointers

ad_init_old()

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

ad_metadata()

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

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 )

ad_mkdir()

int ad_mkdir	(	const char *	path,
		mode_t	mode )

ad_mkrf()

int ad_mkrf ( const char * path )

static

Takes a path to an AppleDouble file and creates the parent .AppleDouble directory

Example: path: "/path/.AppleDouble/file" => mkdir("/path/.AppleDouble/") (in ad_mkdir())

ad_mkrf_osx() [1/2]

int ad_mkrf_osx ( const char *path _U_ )

static

ad_mkrf_osx() [2/2]

int ad_mkrf_osx ( const char * path )

static

ad_mode()

int ad_mode	(	const char *	path,
		mode_t	mode )

ad_mode_st()

int ad_mode_st ( const char * path, mode_t * mode, struct stat * stbuf )

static

ad_open()

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

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

ad	(rw) pointer to struct adouble
path	(r) Path to file or directory
adflags	(r) Flags specifying which fork to open, can be or'd: 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.

Parameters

...	(r) mode used with O_CREATE

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

BUGS:

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

Returns

0 on success, any other value indicates an error

ad_open_df()

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

static

ad_open_hf()

int ad_open_hf ( const char * path, int adflags, int mode, struct adouble * ad )

static

ad_open_hf_ea()

int ad_open_hf_ea ( const char * path, int adflags, int mode _U_, struct adouble * ad )

static

ad_open_hf_v2()

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

static

ad_open_rf()

int ad_open_rf ( const char * path, int adflags, int mode, struct adouble * ad )

static

Open resource fork

ad_open_rf_ea()

int ad_open_rf_ea ( const char * path, int adflags, int mode, struct adouble * ad )

static

ad_open_rf_v2()

int ad_open_rf_v2 ( const char * path, int adflags, int mode _U_, struct adouble * ad )

static

ad_openat()

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

ad_path()

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

ad_path_ea()

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

ad_path_osx()

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

ad_refresh()

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

ad_reso_size() [1/2]

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

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

ad_reso_size() [2/2]

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

ad_setfuid()

int ad_setfuid

(

const uid_t

id

)

ad_stat()

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

ad_valid_header_osx()

int ad_valid_header_osx

(

const char *

path

)

adflags2logstr()

const char * adflags2logstr

(

int

adflags

)

get_eid()

uint32_t get_eid ( uint32_t eid )

static

new_ad_header()

int new_ad_header ( struct adouble * ad, const char * path, struct stat * stp, int adflags )

static

openflags2logstr()

const char * openflags2logstr

(

int

oflags

)

parse_entries()

int parse_entries ( struct adouble * ad, uint16_t nentries, size_t valid_data_len )

static

Read an AppleDouble buffer, returns 0 on success, -1 if an entry was malformatted

Variable Documentation

ad_adouble

struct adouble_fops ad_adouble

static

Initial value:

= {
    &ad_path,
    &ad_mkrf,
    &ad_rebuild_adouble_header_v2,
    &ad_header_read,
    &ad_header_upgrade,
}

ad_adouble_ea

struct adouble_fops ad_adouble_ea

static

Initial value:

= {
 
 
 
 
    &ad_path_osx,
    &ad_mkrf_osx,
 
    &ad_rebuild_adouble_header_ea,
    &ad_header_read_ea,
    &ad_header_upgrade_ea,
}

default_uid

uid_t default_uid = -1

static

entry_order2

const struct entry entry_order2[ADEID_NUM_V2+1]

static

Initial value:

= {
    {ADEID_NAME,        ADEDOFF_NAME_V2,     ADEDLEN_INIT},
    {ADEID_COMMENT,     ADEDOFF_COMMENT_V2,  ADEDLEN_COMMENT},
    {ADEID_FILEDATESI,  ADEDOFF_FILEDATESI,  ADEDLEN_FILEDATESI},
    {ADEID_FINDERI,     ADEDOFF_FINDERI_V2,  ADEDLEN_FINDERI},
    {ADEID_DID,         ADEDOFF_DID,         ADEDLEN_DID},
    {ADEID_AFPFILEI,    ADEDOFF_AFPFILEI,    ADEDLEN_AFPFILEI},
    {ADEID_SHORTNAME,   ADEDOFF_SHORTNAME,   ADEDLEN_INIT},
    {ADEID_PRODOSFILEI, ADEDOFF_PRODOSFILEI, ADEDLEN_PRODOSFILEI},
    {ADEID_PRIVDEV,     ADEDOFF_PRIVDEV,     ADEDLEN_PRIVDEV},
    {ADEID_PRIVINO,     ADEDOFF_PRIVINO,     ADEDLEN_PRIVINO},
    {ADEID_PRIVSYN,     ADEDOFF_PRIVSYN,     ADEDLEN_PRIVSYN},
    {ADEID_PRIVID,      ADEDOFF_PRIVID,      ADEDLEN_PRIVID},
    {ADEID_RFORK,       ADEDOFF_RFORK_V2,    ADEDLEN_INIT},
    {0, 0, 0}
}

entry_order_ea

const struct entry entry_order_ea[ADEID_NUM_EA+1]

static

Initial value:

= {
    {ADEID_FINDERI,    ADEDOFF_FINDERI_EA,    ADEDLEN_FINDERI},
    {ADEID_COMMENT,    ADEDOFF_COMMENT_EA,    ADEDLEN_COMMENT},
    {ADEID_FILEDATESI, ADEDOFF_FILEDATESI_EA, ADEDLEN_FILEDATESI},
    {ADEID_AFPFILEI,   ADEDOFF_AFPFILEI_EA,   ADEDLEN_AFPFILEI},
    {ADEID_PRIVDEV,    ADEDOFF_PRIVDEV_EA,    ADEDLEN_PRIVDEV},
    {ADEID_PRIVINO,    ADEDOFF_PRIVINO_EA,    ADEDLEN_PRIVINO},
    {ADEID_PRIVSYN,    ADEDOFF_PRIVSYN_EA,    ADEDLEN_PRIVSYN},
    {ADEID_PRIVID,     ADEDOFF_PRIVID_EA,     ADEDLEN_PRIVID},
    {0, 0, 0}
}