X-Git-Url: https://arthur.barton.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=libatalk%2Fadouble%2Fad_write.c;h=35ebc222675f33787ca59ced3e7214ab9624db6c;hb=296eb8dfd48fb30bbc4b2371c3e1dabefe9d833d;hp=52b33ea4ffa3db7fb2128d2c658061714a2117c3;hpb=6b814c857d98259bd82737ce8746c6c1d94e9cd5;p=netatalk.git

diff --git a/libatalk/adouble/ad_write.c b/libatalk/adouble/ad_write.c
index 52b33ea4..35ebc222 100644
--- a/libatalk/adouble/ad_write.c
+++ b/libatalk/adouble/ad_write.c
@@ -1,5 +1,5 @@
 /*
- * $Id: ad_write.c,v 1.4 2002-10-11 14:18:39 didg Exp $
+ * $Id: ad_write.c,v 1.11 2010-03-30 12:55:26 franklahm Exp $
  *
  * Copyright (c) 1990,1995 Regents of The University of Michigan.
  * All Rights Reserved.  See COPYRIGHT.
@@ -29,7 +29,7 @@ ssize_t adf_pwrite(struct ad_fd *ad_fd, const void *buf, size_t count, off_t off
     ssize_t		cc;
 
 #ifndef  HAVE_PWRITE
-    if ( ad_fd->adf_off != off ) {
+    if ( ad_fd->adf_off != offset ) {
 	if ( lseek( ad_fd->adf_fd, offset, SEEK_SET ) < 0 ) {
 	    return -1;
 	}
@@ -46,37 +46,37 @@ ssize_t adf_pwrite(struct ad_fd *ad_fd, const void *buf, size_t count, off_t off
     return cc;
 }
 
-
-ssize_t ad_write( ad, eid, off, end, buf, buflen )
-    struct adouble	*ad;
-    const u_int32_t	eid;
-    off_t               off;
-    const int		end;
-    const char		*buf;
-    const size_t	buflen;
+/* end is always 0 */
+ssize_t ad_write(struct adouble *ad, const u_int32_t eid, off_t off, const int end, const char *buf, const size_t buflen)
 {
     struct stat		st;
     ssize_t		cc;
+
+    if (ad_data_fileno(ad) == -2) {
+        /* It's a symlink */
+        errno = EACCES;
+        return -1;
+    }
     
     if ( eid == ADEID_DFORK ) {
 	if ( end ) {
-	    if ( fstat( ad->ad_df.adf_fd, &st ) < 0 ) {
+	    if ( fstat( ad_data_fileno(ad), &st ) < 0 ) {
 		return( -1 );
 	    }
 	    off = st.st_size - off;
 	}
-	cc = adf_pwrite(&ad->ad_df, buf, buflen, off);
+	cc = adf_pwrite(&ad->ad_data_fork, buf, buflen, off);
     } else if ( eid == ADEID_RFORK ) {
         off_t    r_off;
 
 	if ( end ) {
-	    if ( fstat( ad->ad_df.adf_fd, &st ) < 0 ) {
+	    if ( fstat( ad_data_fileno(ad), &st ) < 0 ) {
 		return( -1 );
 	    }
 	    off = st.st_size - off -ad_getentryoff(ad, eid);
 	}
 	r_off = ad_getentryoff(ad, eid) + off;
-	cc = adf_pwrite(&ad->ad_hf, buf, buflen, r_off);
+	cc = adf_pwrite(&ad->ad_resource_fork, buf, buflen, r_off);
 
 	/* sync up our internal buffer  FIXME always false? */
 	if (r_off < ad_getentryoff(ad, ADEID_RFORK)) {
@@ -92,57 +92,80 @@ ssize_t ad_write( ad, eid, off, end, buf, buflen )
     return( cc );
 }
 
-/* set locks here */
-int ad_rtruncate( ad, size )
-    struct adouble	*ad;
-    const size_t	size;
+/* 
+ * the caller set the locks
+ * ftruncate is undefined when the file length is smaller than 'size'
+ */
+int sys_ftruncate(int fd, off_t length)
 {
-    int err;
 
-    if (ad_tmplock(ad, ADEID_RFORK, ADLOCK_WR, 0, 0) < 0)
-      return -2;
+#ifndef  HAVE_PWRITE
+off_t           curpos;
+#endif
+int             err;
+struct stat	st;
+char            c = 0;
 
-    if ( ftruncate( ad->ad_hf.adf_fd,
-	    size + ad->ad_eid[ ADEID_RFORK ].ade_off ) < 0 ) {
-        err = errno;
-        ad_tmplock(ad, ADEID_RFORK, ADLOCK_CLR, 0, 0);
-	errno = err;
-	return( -1 );
+    if (!ftruncate(fd, length)) {
+        return 0;
+    }
+    /* maybe ftruncate doesn't work if we try to extend the size */
+    err = errno;
+
+#ifndef  HAVE_PWRITE
+    /* we only care about file pointer if we don't use pwrite */
+    if ((off_t)-1 == (curpos = lseek(fd, 0, SEEK_CUR)) ) {
+        errno = err;
+        return -1;
+    }
+#endif
+
+    if ( fstat( fd, &st ) < 0 ) {
+        errno = err;
+        return -1;
+    }
+    
+    if (st.st_size > length) {
+        errno = err;
+        return -1;
     }
-    ad->ad_rlen = size;    
 
-#if 0
-    ad->ad_eid[ ADEID_RFORK ].ade_len = size;
-    if ( lseek( ad->ad_hf.adf_fd, ad->ad_eid[ADEID_RFORK].ade_off, 
-		SEEK_SET ) < 0 ) {
-        err = errno;
-        ad_tmplock(ad, ADEID_RFORK, ADLOCK_CLR, 0, 0);
-	errno = err;
-	return( -1 );
+    if (lseek(fd, length -1, SEEK_SET) != length -1) {
+        errno = err;
+        return -1;
     }
 
-    ad->ad_hf.adf_off = ad->ad_eid[ADEID_RFORK].ade_off;
+    if (1 != write( fd, &c, 1 )) {
+        /* return the write errno */
+        return -1;
+    }
+
+#ifndef  HAVE_PWRITE
+    if (curpos != lseek(fd, curpos,  SEEK_SET)) {
+        errno = err;
+        return -1;
+    }
 #endif
-    ad_tmplock(ad, ADEID_RFORK, ADLOCK_CLR, 0, 0);
-    return( 0 );
+
+    return 0;    
 }
 
-int ad_dtruncate(ad, size)
-    struct adouble	*ad;
-    const size_t	size;
+/* ------------------------ */
+int ad_rtruncate( struct adouble *ad, const off_t size)
 {
-    int err;
+    if ( sys_ftruncate( ad_reso_fileno(ad),
+	    size + ad->ad_eid[ ADEID_RFORK ].ade_off ) < 0 ) {
+	return -1;
+    }
+    ad->ad_rlen = size;    
 
-    if (ad_tmplock(ad, ADEID_DFORK, ADLOCK_WR, 0, 0) < 0)
-      return -2;
+    return 0;
+}
 
-    if (ftruncate(ad->ad_df.adf_fd, size) < 0) {
-      err = errno;
-      ad_tmplock(ad, ADEID_DFORK, ADLOCK_CLR, 0, 0);
-      errno = err;
+int ad_dtruncate(struct adouble *ad, const off_t size)
+{
+    if (sys_ftruncate(ad_data_fileno(ad), size) < 0) {
       return -1;
-    } else 
-      ad_tmplock(ad, ADEID_DFORK, ADLOCK_CLR, 0, 0);
-
+    }
     return 0;
 }