libatalk/adouble/ad_write.c

   1 /*
   2  * $Id: ad_write.c,v 1.4 2002-10-11 14:18:39 didg Exp $
   3  *
   4  * Copyright (c) 1990,1995 Regents of The University of Michigan.
   5  * All Rights Reserved.  See COPYRIGHT.
   6  */
   7
   8 #ifdef HAVE_CONFIG_H
   9 #include "config.h"
  10 #endif /* HAVE_CONFIG_H */
  11
  12 #include <atalk/adouble.h>
  13
  14 #include <string.h>
  15 #include <sys/param.h>
  16 #include <errno.h>
  17
  18
  19 #ifndef MIN
  20 #define MIN(a,b)        ((a)<(b)?(a):(b))
  21 #endif /* ! MIN */
  22
  23 /* XXX: locking has to be checked before each stream of consecutive
  24  *      ad_writes to prevent a lock in the middle from causing problems.
  25  */
  26
  27 ssize_t adf_pwrite(struct ad_fd *ad_fd, const void *buf, size_t count, off_t offset)
  28 {
  29     ssize_t             cc;
  30
  31 #ifndef  HAVE_PWRITE
  32     if ( ad_fd->adf_off != off ) {
  33         if ( lseek( ad_fd->adf_fd, offset, SEEK_SET ) < 0 ) {
  34             return -1;
  35         }
  36         ad_fd->adf_off = offset;
  37     }
  38     cc = write( ad_fd->adf_fd, buf, count );
  39     if ( cc < 0 ) {
  40         return -1;
  41     }
  42     ad_fd->adf_off += cc;
  43 #else
  44    cc = pwrite(ad_fd->adf_fd, buf, count, offset );
  45 #endif
  46     return cc;
  47 }
  48
  49
  50 ssize_t ad_write( ad, eid, off, end, buf, buflen )
  51     struct adouble      *ad;
  52     const u_int32_t     eid;
  53     off_t               off;
  54     const int           end;
  55     const char          *buf;
  56     const size_t        buflen;
  57 {
  58     struct stat         st;
  59     ssize_t             cc;
  60
  61     if ( eid == ADEID_DFORK ) {
  62         if ( end ) {
  63             if ( fstat( ad->ad_df.adf_fd, &st ) < 0 ) {
  64                 return( -1 );
  65             }
  66             off = st.st_size - off;
  67         }
  68         cc = adf_pwrite(&ad->ad_df, buf, buflen, off);
  69     } else if ( eid == ADEID_RFORK ) {
  70         off_t    r_off;
  71
  72         if ( end ) {
  73             if ( fstat( ad->ad_df.adf_fd, &st ) < 0 ) {
  74                 return( -1 );
  75             }
  76             off = st.st_size - off -ad_getentryoff(ad, eid);
  77         }
  78         r_off = ad_getentryoff(ad, eid) + off;
  79         cc = adf_pwrite(&ad->ad_hf, buf, buflen, r_off);
  80
  81         /* sync up our internal buffer  FIXME always false? */
  82         if (r_off < ad_getentryoff(ad, ADEID_RFORK)) {
  83             memcpy(ad->ad_data + r_off, buf, MIN(sizeof(ad->ad_data) -r_off, cc));
  84         }
  85         if ( ad->ad_rlen  < r_off + cc ) {
  86              ad->ad_rlen = r_off + cc;
  87         }
  88     }
  89     else {
  90         return -1; /* we don't know how to write if it's not a ressource or data fork */
  91     }
  92     return( cc );
  93 }
  94
  95 /* set locks here */
  96 int ad_rtruncate( ad, size )
  97     struct adouble      *ad;
  98     const size_t        size;
  99 {
 100     int err;
 101
 102     if (ad_tmplock(ad, ADEID_RFORK, ADLOCK_WR, 0, 0) < 0)
 103       return -2;
 104
 105     if ( ftruncate( ad->ad_hf.adf_fd,
 106             size + ad->ad_eid[ ADEID_RFORK ].ade_off ) < 0 ) {
 107         err = errno;
 108         ad_tmplock(ad, ADEID_RFORK, ADLOCK_CLR, 0, 0);
 109         errno = err;
 110         return( -1 );
 111     }
 112     ad->ad_rlen = size;
 113
 114 #if 0
 115     ad->ad_eid[ ADEID_RFORK ].ade_len = size;
 116     if ( lseek( ad->ad_hf.adf_fd, ad->ad_eid[ADEID_RFORK].ade_off,
 117                 SEEK_SET ) < 0 ) {
 118         err = errno;
 119         ad_tmplock(ad, ADEID_RFORK, ADLOCK_CLR, 0, 0);
 120         errno = err;
 121         return( -1 );
 122     }
 123
 124     ad->ad_hf.adf_off = ad->ad_eid[ADEID_RFORK].ade_off;
 125 #endif
 126     ad_tmplock(ad, ADEID_RFORK, ADLOCK_CLR, 0, 0);
 127     return( 0 );
 128 }
 129
 130 int ad_dtruncate(ad, size)
 131     struct adouble      *ad;
 132     const size_t        size;
 133 {
 134     int err;
 135
 136     if (ad_tmplock(ad, ADEID_DFORK, ADLOCK_WR, 0, 0) < 0)
 137       return -2;
 138
 139     if (ftruncate(ad->ad_df.adf_fd, size) < 0) {
 140       err = errno;
 141       ad_tmplock(ad, ADEID_DFORK, ADLOCK_CLR, 0, 0);
 142       errno = err;
 143       return -1;
 144     } else
 145       ad_tmplock(ad, ADEID_DFORK, ADLOCK_CLR, 0, 0);
 146
 147     return 0;
 148 }