/*
- * $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.
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;
}
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)) {
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;
}