libatalk/adouble/ad_write.c

   1 /*
   2  * Copyright (c) 1990,1995 Regents of The University of Michigan.
   3  * All Rights Reserved.  See COPYRIGHT.
   4  */
   5
   6 #ifdef HAVE_CONFIG_H
   7 #include "config.h"
   8 #endif /* HAVE_CONFIG_H */
   9
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <sys/param.h>
  13 #include <errno.h>
  14
  15 #include <atalk/adouble.h>
  16 #include <atalk/ea.h>
  17 #include <atalk/bstrlib.h>
  18 #include <atalk/bstradd.h>
  19 #include <atalk/logger.h>
  20 #include <atalk/util.h>
  21 #include <atalk/errchk.h>
  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 != offset ) {
  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 /* end is always 0 */
  50 ssize_t ad_write(struct adouble *ad, uint32_t eid, off_t off, int end, const char *buf, size_t buflen)
  51 {
  52     EC_INIT;
  53     struct stat         st;
  54     ssize_t             cc;
  55     size_t roundup;
  56     off_t    r_off;
  57
  58     if (ad_data_fileno(ad) == -2) {
  59         /* It's a symlink */
  60         errno = EACCES;
  61         return -1;
  62     }
  63
  64     LOG(log_debug, logtype_default, "ad_write: off: %ju, size: %zu, eabuflen: %zu",
  65         (uintmax_t)off, buflen, ad->ad_rlen);
  66
  67     if ( eid == ADEID_DFORK ) {
  68         if ( end ) {
  69             if ( fstat( ad_data_fileno(ad), &st ) < 0 ) {
  70                 return( -1 );
  71             }
  72             off = st.st_size - off;
  73         }
  74         cc = adf_pwrite(&ad->ad_data_fork, buf, buflen, off);
  75     } else if ( eid == ADEID_RFORK ) {
  76         switch (ad->ad_vers) {
  77         case AD_VERSION2:
  78
  79             if ( end ) {
  80                 if ( fstat( ad_data_fileno(ad), &st ) < 0 )
  81                     return( -1 );
  82                 off = st.st_size - off -ad_getentryoff(ad, eid);
  83             }
  84             r_off = ad_getentryoff(ad, eid) + off;
  85             cc = adf_pwrite(&ad->ad_resource_fork, buf, buflen, r_off);
  86
  87             /* sync up our internal buffer  FIXME always false? */
  88             if (r_off < ad_getentryoff(ad, ADEID_RFORK))
  89                 memcpy(ad->ad_data + r_off, buf, MIN(sizeof(ad->ad_data) -r_off, cc));
  90             if ( ad->ad_rlen < off + cc )
  91                 ad->ad_rlen = off + cc;
  92             break;
  93
  94         case AD_VERSION_EA:
  95 #ifndef HAVE_EAFD
  96             LOG(log_debug, logtype_default, "ad_write: off: %ju, size: %zu, eabuflen: %zu",
  97                 (uintmax_t)off, buflen, ad->ad_rlen);
  98             if (ad->ad_rlen == 0) {
  99                 EC_NULL_LOG( ad->ad_resforkbuf = malloc(off + buflen) );
 100                 ad->ad_rlen = off + buflen;
 101             } else if ((off + buflen) > ad->ad_rlen) {
 102                 EC_NULL_LOG( ad->ad_resforkbuf = realloc(ad->ad_resforkbuf, off + buflen) );
 103                 ad->ad_rlen = off + buflen;
 104             }
 105
 106             memcpy(ad->ad_resforkbuf + off, buf, buflen);
 107             if (ad->ad_rlen > 0)
 108                 if (fsetrsrcea(ad, ad_data_fileno(ad), AD_EA_RESO, ad->ad_resforkbuf, ad->ad_rlen, 0) == -1)
 109                     ret = -1;
 110             cc = buflen;
 111             LOG(log_debug, logtype_default, "ad_write: off: %ju, size: %zu, eabuflen: %zu",
 112                 (uintmax_t)off, buflen, ad->ad_rlen);
 113 #endif
 114             break;
 115
 116         default:
 117             return -1;
 118         }
 119     } else {
 120         return -1; /* we don't know how to write if it's not a ressource or data fork */
 121     }
 122
 123 EC_CLEANUP:
 124     if (ret != 0)
 125         return ret;
 126     return( cc );
 127 }
 128
 129 /*
 130  * the caller set the locks
 131  * ftruncate is undefined when the file length is smaller than 'size'
 132  */
 133 int sys_ftruncate(int fd, off_t length)
 134 {
 135
 136 #ifndef  HAVE_PWRITE
 137 off_t           curpos;
 138 #endif
 139 int             err;
 140 struct stat     st;
 141 char            c = 0;
 142
 143     if (!ftruncate(fd, length)) {
 144         return 0;
 145     }
 146     /* maybe ftruncate doesn't work if we try to extend the size */
 147     err = errno;
 148
 149 #ifndef  HAVE_PWRITE
 150     /* we only care about file pointer if we don't use pwrite */
 151     if ((off_t)-1 == (curpos = lseek(fd, 0, SEEK_CUR)) ) {
 152         errno = err;
 153         return -1;
 154     }
 155 #endif
 156
 157     if ( fstat( fd, &st ) < 0 ) {
 158         errno = err;
 159         return -1;
 160     }
 161
 162     if (st.st_size > length) {
 163         errno = err;
 164         return -1;
 165     }
 166
 167     if (lseek(fd, length -1, SEEK_SET) != length -1) {
 168         errno = err;
 169         return -1;
 170     }
 171
 172     if (1 != write( fd, &c, 1 )) {
 173         /* return the write errno */
 174         return -1;
 175     }
 176
 177 #ifndef  HAVE_PWRITE
 178     if (curpos != lseek(fd, curpos,  SEEK_SET)) {
 179         errno = err;
 180         return -1;
 181     }
 182 #endif
 183
 184     return 0;
 185 }
 186
 187 /* ------------------------ */
 188 int ad_rtruncate( struct adouble *ad, const off_t size)
 189 {
 190     if (ad->ad_vers != AD_VERSION_EA)
 191         if (sys_ftruncate(ad_reso_fileno(ad), size + ad->ad_eid[ ADEID_RFORK ].ade_off ) < 0 )
 192             return -1;
 193
 194     ad->ad_rlen = size;
 195
 196     return 0;
 197 }
 198
 199 int ad_dtruncate(struct adouble *ad, const off_t size)
 200 {
 201     if (sys_ftruncate(ad_data_fileno(ad), size) < 0)
 202         return -1;
 203
 204     return 0;
 205 }