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
  21 #ifndef MIN
  22 #define MIN(a,b)        ((a)<(b)?(a):(b))
  23 #endif /* ! MIN */
  24
  25 static int fsetrsrcea(struct adouble *ad, int fd, const char *eaname, const void *value, size_t size, int flags)
  26 {
  27     if (ad->ad_maxeafssize >= size) {
  28         if (sys_fsetxattr(fd, eaname, value, size, 0) == -1)
  29             return -1;
  30         return 0;
  31     }
  32
  33     /* rsrcfork is larger then maximum EA support by fs so we have to split it */
  34     int i;
  35     int eas = (size / ad->ad_maxeafssize);
  36     size_t remain = size - (eas * ad->ad_maxeafssize);
  37     bstring eachunk;
  38
  39     LOG(log_debug, logtype_default, "fsetrsrcea(\"%s\"): size: %zu, maxea: %zu, eas: %d, remain: %zu",
  40         eaname, size, ad->ad_maxeafssize, eas, remain);
  41
  42     for (i = 0; i < eas; i++) {
  43         if ((eachunk = bformat("%s.%d", eaname, i + 1)) == NULL)
  44             return -1;
  45         if (sys_fsetxattr(fd, bdata(eachunk), value + (i * ad->ad_maxeafssize), ad->ad_maxeafssize, 0) == -1) {
  46             LOG(log_error, logtype_default, "fsetrsrcea(\"%s\"): %s", bdata(eachunk), strerror(errno));
  47             bdestroy(eachunk);
  48             return -1;
  49         }
  50         bdestroy(eachunk);
  51     }
  52
  53     if ((eachunk = bformat("%s.%d", eaname, i + 1)) == NULL)
  54         return -1;
  55     if (sys_fsetxattr(fd, bdata(eachunk), value + (i * ad->ad_maxeafssize), remain, 0) == -1) {
  56         LOG(log_error, logtype_default, "fsetrsrcea(\"%s\"): %s", bdata(eachunk), strerror(errno));
  57         return -1;
  58     }
  59     bdestroy(eachunk);
  60
  61     return 0;
  62 }
  63
  64
  65
  66 /* XXX: locking has to be checked before each stream of consecutive
  67  *      ad_writes to prevent a lock in the middle from causing problems.
  68  */
  69
  70 ssize_t adf_pwrite(struct ad_fd *ad_fd, const void *buf, size_t count, off_t offset)
  71 {
  72     ssize_t             cc;
  73
  74 #ifndef  HAVE_PWRITE
  75     if ( ad_fd->adf_off != offset ) {
  76         if ( lseek( ad_fd->adf_fd, offset, SEEK_SET ) < 0 ) {
  77             return -1;
  78         }
  79         ad_fd->adf_off = offset;
  80     }
  81     cc = write( ad_fd->adf_fd, buf, count );
  82     if ( cc < 0 ) {
  83         return -1;
  84     }
  85     ad_fd->adf_off += cc;
  86 #else
  87    cc = pwrite(ad_fd->adf_fd, buf, count, offset );
  88 #endif
  89     return cc;
  90 }
  91
  92 /* end is always 0 */
  93 ssize_t ad_write(struct adouble *ad, uint32_t eid, off_t off, int end, const char *buf, size_t buflen)
  94 {
  95     struct stat         st;
  96     ssize_t             cc;
  97     size_t roundup;
  98     off_t    r_off;
  99
 100     if (ad_data_fileno(ad) == -2) {
 101         /* It's a symlink */
 102         errno = EACCES;
 103         return -1;
 104     }
 105
 106     if ( eid == ADEID_DFORK ) {
 107         if ( end ) {
 108             if ( fstat( ad_data_fileno(ad), &st ) < 0 ) {
 109                 return( -1 );
 110             }
 111             off = st.st_size - off;
 112         }
 113         cc = adf_pwrite(&ad->ad_data_fork, buf, buflen, off);
 114     } else if ( eid == ADEID_RFORK ) {
 115         switch (ad->ad_flags) {
 116         case AD_VERSION2:
 117
 118             if ( end ) {
 119                 if ( fstat( ad_data_fileno(ad), &st ) < 0 )
 120                     return( -1 );
 121                 off = st.st_size - off -ad_getentryoff(ad, eid);
 122             }
 123             r_off = ad_getentryoff(ad, eid) + off;
 124             cc = adf_pwrite(&ad->ad_resource_fork, buf, buflen, r_off);
 125
 126             /* sync up our internal buffer  FIXME always false? */
 127             if (r_off < ad_getentryoff(ad, ADEID_RFORK))
 128                 memcpy(ad->ad_data + r_off, buf, MIN(sizeof(ad->ad_data) -r_off, cc));
 129             if ( ad->ad_rlen < off + cc )
 130                 ad->ad_rlen = off + cc;
 131             break;
 132
 133         case AD_VERSION_EA:
 134             if ((off + buflen) > ad->ad_resforkbufsize) {
 135                 roundup = (((off + buflen) / RFORK_EA_ALLOCSIZE) + 1) * RFORK_EA_ALLOCSIZE;
 136                 if ((ad->ad_resforkbuf = realloc(ad->ad_resforkbuf, roundup)) == NULL)
 137                     return -1;
 138                 ad->ad_resforkbufsize = roundup;
 139             }
 140             memcpy(ad->ad_resforkbuf + off, buf, buflen);
 141             if ((off + buflen) > ad->ad_rlen)
 142                 ad->ad_rlen = off + buflen;
 143
 144             if (fsetrsrcea(ad, ad_data_fileno(ad), AD_EA_RESO, ad->ad_resforkbuf, ad->ad_rlen, 0) == -1)
 145                 return -1;
 146             cc = buflen;
 147             break;
 148
 149         default:
 150             return -1;
 151         }
 152     } else {
 153         return -1; /* we don't know how to write if it's not a ressource or data fork */
 154     }
 155
 156     return( cc );
 157 }
 158
 159 /*
 160  * the caller set the locks
 161  * ftruncate is undefined when the file length is smaller than 'size'
 162  */
 163 int sys_ftruncate(int fd, off_t length)
 164 {
 165
 166 #ifndef  HAVE_PWRITE
 167 off_t           curpos;
 168 #endif
 169 int             err;
 170 struct stat     st;
 171 char            c = 0;
 172
 173     if (!ftruncate(fd, length)) {
 174         return 0;
 175     }
 176     /* maybe ftruncate doesn't work if we try to extend the size */
 177     err = errno;
 178
 179 #ifndef  HAVE_PWRITE
 180     /* we only care about file pointer if we don't use pwrite */
 181     if ((off_t)-1 == (curpos = lseek(fd, 0, SEEK_CUR)) ) {
 182         errno = err;
 183         return -1;
 184     }
 185 #endif
 186
 187     if ( fstat( fd, &st ) < 0 ) {
 188         errno = err;
 189         return -1;
 190     }
 191
 192     if (st.st_size > length) {
 193         errno = err;
 194         return -1;
 195     }
 196
 197     if (lseek(fd, length -1, SEEK_SET) != length -1) {
 198         errno = err;
 199         return -1;
 200     }
 201
 202     if (1 != write( fd, &c, 1 )) {
 203         /* return the write errno */
 204         return -1;
 205     }
 206
 207 #ifndef  HAVE_PWRITE
 208     if (curpos != lseek(fd, curpos,  SEEK_SET)) {
 209         errno = err;
 210         return -1;
 211     }
 212 #endif
 213
 214     return 0;
 215 }
 216
 217 /* ------------------------ */
 218 int ad_rtruncate( struct adouble *ad, const off_t size)
 219 {
 220     if (ad->ad_flags != AD_VERSION_EA)
 221         if (sys_ftruncate(ad_reso_fileno(ad), size + ad->ad_eid[ ADEID_RFORK ].ade_off ) < 0 )
 222             return -1;
 223
 224     ad->ad_rlen = size;
 225
 226     return 0;
 227 }
 228
 229 int ad_dtruncate(struct adouble *ad, const off_t size)
 230 {
 231     if (sys_ftruncate(ad_data_fileno(ad), size) < 0)
 232         return -1;
 233
 234     return 0;
 235 }