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         if (end) {
  77             if (fstat( ad_reso_fileno(ad), &st ) < 0)
  78                 return(-1);
  79             off = st.st_size - off - ad_getentryoff(ad, eid);
  80         }
  81         if (ad->ad_vers == AD_VERSION_EA) {
  82 #ifdef HAVE_EAFD
  83             r_off = off;
  84 #else
  85             r_off = ADEDOFF_RFORK_OSX + off;
  86 #endif
  87         } else {
  88             r_off = ad_getentryoff(ad, eid) + off;
  89         }
  90         cc = adf_pwrite(&ad->ad_resource_fork, buf, buflen, r_off);
  91
  92         if ( ad->ad_rlen < off + cc )
  93             ad->ad_rlen = off + cc;
  94     } else {
  95         return -1; /* we don't know how to write if it's not a ressource or data fork */
  96     }
  97
  98 EC_CLEANUP:
  99     if (ret != 0)
 100         return ret;
 101     return( cc );
 102 }
 103
 104 /*
 105  * the caller set the locks
 106  * ftruncate is undefined when the file length is smaller than 'size'
 107  */
 108 int sys_ftruncate(int fd, off_t length)
 109 {
 110
 111 #ifndef  HAVE_PWRITE
 112 off_t           curpos;
 113 #endif
 114 int             err;
 115 struct stat     st;
 116 char            c = 0;
 117
 118     if (!ftruncate(fd, length)) {
 119         return 0;
 120     }
 121     /* maybe ftruncate doesn't work if we try to extend the size */
 122     err = errno;
 123
 124 #ifndef  HAVE_PWRITE
 125     /* we only care about file pointer if we don't use pwrite */
 126     if ((off_t)-1 == (curpos = lseek(fd, 0, SEEK_CUR)) ) {
 127         errno = err;
 128         return -1;
 129     }
 130 #endif
 131
 132     if ( fstat( fd, &st ) < 0 ) {
 133         errno = err;
 134         return -1;
 135     }
 136
 137     if (st.st_size > length) {
 138         errno = err;
 139         return -1;
 140     }
 141
 142     if (lseek(fd, length -1, SEEK_SET) != length -1) {
 143         errno = err;
 144         return -1;
 145     }
 146
 147     if (1 != write( fd, &c, 1 )) {
 148         /* return the write errno */
 149         return -1;
 150     }
 151
 152 #ifndef  HAVE_PWRITE
 153     if (curpos != lseek(fd, curpos,  SEEK_SET)) {
 154         errno = err;
 155         return -1;
 156     }
 157 #endif
 158
 159     return 0;
 160 }
 161
 162 /* ------------------------ */
 163 int ad_rtruncate( struct adouble *ad, const off_t size)
 164 {
 165     if (sys_ftruncate(ad_reso_fileno(ad), size + ad->ad_eid[ ADEID_RFORK ].ade_off ) < 0 ) {
 166         LOG(log_error, logtype_default, "sys_ftruncate: %s", strerror(errno));
 167         return -1;
 168     }
 169
 170     ad->ad_rlen = size;
 171
 172     return 0;
 173 }
 174
 175 int ad_dtruncate(struct adouble *ad, const off_t size)
 176 {
 177     if (sys_ftruncate(ad_data_fileno(ad), size) < 0) {
 178         LOG(log_error, logtype_default, "sys_ftruncate(fd: %d): %s",
 179             ad_data_fileno(ad), strerror(errno));
 180         return -1;
 181     }
 182
 183     return 0;
 184 }
 185
 186 /* ----------------------- */
 187 static int copy_all(const int dfd, const void *buf,
 188                                size_t buflen)
 189 {
 190     ssize_t cc;
 191
 192     while (buflen > 0) {
 193         if ((cc = write(dfd, buf, buflen)) < 0) {
 194             switch (errno) {
 195             case EINTR:
 196                 continue;
 197             default:
 198                 return -1;
 199             }
 200         }
 201         buflen -= cc;
 202     }
 203
 204     return 0;
 205 }
 206
 207 /* --------------------------
 208  * copy only the fork data stream
 209 */
 210 int copy_fork(int eid, struct adouble *add, struct adouble *ads)
 211 {
 212     ssize_t cc;
 213     int     err = 0;
 214     char    filebuf[8192];
 215     int     sfd, dfd;
 216
 217     if (eid == ADEID_DFORK) {
 218         sfd = ad_data_fileno(ads);
 219         dfd = ad_data_fileno(add);
 220     }
 221     else {
 222         sfd = ad_reso_fileno(ads);
 223         dfd = ad_reso_fileno(add);
 224     }
 225
 226     if ((off_t)-1 == lseek(sfd, ad_getentryoff(ads, eid), SEEK_SET))
 227         return -1;
 228
 229     if ((off_t)-1 == lseek(dfd, ad_getentryoff(add, eid), SEEK_SET))
 230         return -1;
 231
 232 #if 0 /* ifdef SENDFILE_FLAVOR_LINUX */
 233     /* doesn't work With 2.6 FIXME, only check for EBADFD ? */
 234     off_t   offset = 0;
 235     size_t  size;
 236     struct stat         st;
 237     #define BUF 128*1024*1024
 238
 239     if (fstat(sfd, &st) == 0) {
 240
 241         while (1) {
 242             if ( offset >= st.st_size) {
 243                return 0;
 244             }
 245             size = (st.st_size -offset > BUF)?BUF:st.st_size -offset;
 246             if ((cc = sys_sendfile(dfd, sfd, &offset, size)) < 0) {
 247                 switch (errno) {
 248                 case ENOSYS:
 249                 case EINVAL:  /* there's no guarantee that all fs support sendfile */
 250                     goto no_sendfile;
 251                 default:
 252                     return -1;
 253                 }
 254             }
 255         }
 256     }
 257     no_sendfile:
 258     lseek(sfd, offset, SEEK_SET);
 259 #endif
 260
 261     while (1) {
 262         if ((cc = read(sfd, filebuf, sizeof(filebuf))) < 0) {
 263             if (errno == EINTR)
 264                 continue;
 265             err = -1;
 266             break;
 267         }
 268
 269         if (!cc || ((err = copy_all(dfd, filebuf, cc)) < 0)) {
 270             break;
 271         }
 272     }
 273     return err;
 274 }