&& s_of->key.dev == of->key.dev
&& s_of->key.inode == of->key.inode ) {
if (!done) {
- strlcpy( of_name(of), newpath, of->of_ad->ad_m_namelen);
+ free(of_name(of));
+ if ((of_name(of) = strdup(newpath)) == NULL)
+ return AFPERR_MISC;
done = 1;
}
if (newdir != olddir)
/* initialize to zero. This is important to ensure that
ad_open really does reinitialize the structure. */
ad_init(ad, vol);
-
- ad->ad_m_namelen = UTF8FILELEN_EARLY +1;
- /* here's the deal: we allocate enough for the standard mac file length.
- * in the future, we'll reallocate in fairly large jumps in case
- * of long unicode names */
- if (( ad->ad_m_name =(char *)malloc( ad->ad_m_namelen )) == NULL ) {
+ if ((ad->ad_name = strdup(path)) == NULL) {
LOG(log_error, logtype_afpd, "of_alloc: malloc: %s", strerror(errno) );
free(ad);
free(of);
oforks[ of_refnum ] = NULL;
return NULL;
}
- strlcpy( ad->ad_m_name, path, ad->ad_m_namelen);
} else {
/* Increase the refcount on this struct adouble. This is
decremented again in oforc_dealloc. */
}
/* -------------------------- */
-int of_stat(struct path *path)
+int of_stat(const struct vol *vol, struct path *path)
{
int ret;
path->st_errno = 0;
path->st_valid = 1;
- if ((ret = lstat(path->u_name, &path->st)) < 0) {
+ if ((ret = ostat(path->u_name, &path->st, vol_syml_opt(vol))) < 0) {
LOG(log_debug, logtype_afpd, "of_stat('%s/%s': %s)",
cfrombstr(curdir->d_fullpath), path->u_name, strerror(errno));
path->st_errno = errno;
if (*path->m_name) {
/* not curdir */
- return of_stat (path);
+ return of_stat(vol, path);
}
path->st_errno = 0;
path->st_valid = 1;
LOG(log_debug, logtype_afpd, "of_statdir: stating: '%s'", pathname);
- if (!(ret = lstat(pathname, &path->st)))
+ if (!(ret = ostat(pathname, &path->st, vol_syml_opt(vol))))
return 0;
path->st_errno = errno;
return -1;
path->st_errno = 0;
- if ((ret = lstat(cfrombstr(path->d_dir->d_u_name), &path->st)) < 0)
+ if ((ret = ostat(cfrombstr(path->d_dir->d_u_name), &path->st, vol_syml_opt(vol))) < 0)
path->st_errno = errno;
}
}
/* -------------------------- */
-struct ofork *of_findname(struct path *path)
+struct ofork *of_findname(const struct vol *vol, struct path *path)
{
struct ofork *of;
struct file_key key;
if (!path->st_valid) {
- of_stat(path);
+ of_stat(vol, path);
}
if (path->st_errno)
}
#endif
-void of_dealloc( struct ofork *of)
+void of_dealloc(struct ofork *of)
{
if (!oforks)
return;
of->of_ad->ad_refcount--;
if ( of->of_ad->ad_refcount <= 0) {
- free( of->of_ad->ad_m_name );
+ free( of->of_ad->ad_name );
free( of->of_ad);
- } else {/* someone's still using it. just free this user's locks */
- ad_unlock(of->of_ad, of->of_refnum, of->of_flags & AFPFORK_ERROR ? 0 : 1);
}
free( of );
}
/* --------------------------- */
-int of_closefork(struct ofork *ofork)
+int of_closefork(const AFPObj *obj, struct ofork *ofork)
{
struct timeval tv;
int adflags = 0;
/* Somone has used write_fork, we assume file was changed, register it to file change event api */
if (ofork->of_flags & AFPFORK_MODIFIED) {
- fce_register_file_modification(ofork);
+ struct dir *dir = dirlookup(ofork->of_vol, ofork->of_did);
+ if (dir) {
+ bstring forkpath = bformat("%s/%s", bdata(dir->d_fullpath), of_name(ofork));
+ fce_register(FCE_FILE_MODIFY, bdata(forkpath), NULL, fce_file);
+ bdestroy(forkpath);
+ }
}
+ ad_unlock(ofork->of_ad, ofork->of_refnum, ofork->of_flags & AFPFORK_ERROR ? 0 : 1);
+
+#ifdef HAVE_FSHARE_T
+ if (obj->options.flags & OPTION_SHARE_RESERV) {
+ fshare_t shmd;
+ shmd.f_id = ofork->of_refnum;
+ if (AD_DATA_OPEN(ofork->of_ad))
+ fcntl(ad_data_fileno(ofork->of_ad), F_UNSHARE, &shmd);
+ if (AD_RSRC_OPEN(ofork->of_ad))
+ fcntl(ad_reso_fileno(ofork->of_ad), F_UNSHARE, &shmd);
+ }
+#endif
+
ret = 0;
if ( ad_close( ofork->of_ad, adflags | ADFLAGS_SETSHRMD) < 0 ) {
ret = -1;
}
- of_dealloc( ofork );
+ of_dealloc(ofork);
+
return ret;
}
struct ofork *of;
struct adouble *adp;
- if ((of = of_findname(path))) {
+ if ((of = of_findname(vol, path))) {
adp = of->of_ad;
} else {
ad_init(ad, vol);
/* ----------------------
close all forks for a volume
*/
-void of_closevol(const struct vol *vol)
+void of_closevol(const AFPObj *obj, const struct vol *vol)
{
int refnum;
for ( refnum = 0; refnum < nforks; refnum++ ) {
if (oforks[ refnum ] != NULL && oforks[refnum]->of_vol == vol) {
- if (of_closefork( oforks[ refnum ]) < 0 ) {
+ if (of_closefork(obj, oforks[ refnum ]) < 0 ) {
LOG(log_error, logtype_afpd, "of_closevol: %s", strerror(errno) );
}
}
/* ----------------------
close all forks for a volume
*/
-void of_close_all_forks(void)
+void of_close_all_forks(const AFPObj *obj)
{
int refnum;
for ( refnum = 0; refnum < nforks; refnum++ ) {
if (oforks[ refnum ] != NULL) {
- if (of_closefork( oforks[ refnum ]) < 0 ) {
+ if (of_closefork(obj, oforks[ refnum ]) < 0 ) {
LOG(log_error, logtype_afpd, "of_close_all_forks: %s", strerror(errno) );
}
}