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_vers) {
 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 (ad->ad_resforkbuf == NULL) {
 135                 ad->ad_rlen = off + buflen;
 136                 if ((ad->ad_resforkbuf = malloc(ad->ad_rlen)) == NULL) {
 137                     ad->ad_rlen = 0;
 138                     return -1;
 139                 }
 140             }
 141             if ((off + buflen) > ad->ad_rlen) {
 142                 if ((ad->ad_resforkbuf = realloc(ad->ad_resforkbuf, off + buflen)) == NULL)
 143                     return -1;
 144                 ad->ad_rlen = off + buflen;
 145             }
 146             memcpy(ad->ad_resforkbuf + off, buf, buflen);
 147
 148             if (fsetrsrcea(ad, ad_data_fileno(ad), AD_EA_RESO, ad->ad_resforkbuf, ad->ad_rlen, 0) == -1)
 149                 return -1;
 150             cc = buflen;
 151             break;
 152
 153         default:
 154             return -1;
 155         }
 156     } else {
 157         return -1; /* we don't know how to write if it's not a ressource or data fork */
 158     }
 159
 160     return( cc );
 161 }
 162
 163 /*
 164  * the caller set the locks
 165  * ftruncate is undefined when the file length is smaller than 'size'
 166  */
 167 int sys_ftruncate(int fd, off_t length)
 168 {
 169
 170 #ifndef  HAVE_PWRITE
 171 off_t           curpos;
 172 #endif
 173 int             err;
 174 struct stat     st;
 175 char            c = 0;
 176
 177     if (!ftruncate(fd, length)) {
 178         return 0;
 179     }
 180     /* maybe ftruncate doesn't work if we try to extend the size */
 181     err = errno;
 182
 183 #ifndef  HAVE_PWRITE
 184     /* we only care about file pointer if we don't use pwrite */
 185     if ((off_t)-1 == (curpos = lseek(fd, 0, SEEK_CUR)) ) {
 186         errno = err;
 187         return -1;
 188     }
 189 #endif
 190
 191     if ( fstat( fd, &st ) < 0 ) {
 192         errno = err;
 193         return -1;
 194     }
 195
 196     if (st.st_size > length) {
 197         errno = err;
 198         return -1;
 199     }
 200
 201     if (lseek(fd, length -1, SEEK_SET) != length -1) {
 202         errno = err;
 203         return -1;
 204     }
 205
 206     if (1 != write( fd, &c, 1 )) {
 207         /* return the write errno */
 208         return -1;
 209     }
 210
 211 #ifndef  HAVE_PWRITE
 212     if (curpos != lseek(fd, curpos,  SEEK_SET)) {
 213         errno = err;
 214         return -1;
 215     }
 216 #endif
 217
 218     return 0;
 219 }
 220
 221 /* ------------------------ */
 222 int ad_rtruncate( struct adouble *ad, const off_t size)
 223 {
 224     if (ad->ad_vers != AD_VERSION_EA)
 225         if (sys_ftruncate(ad_reso_fileno(ad), size + ad->ad_eid[ ADEID_RFORK ].ade_off ) < 0 )
 226             return -1;
 227
 228     ad->ad_rlen = size;
 229
 230     return 0;
 231 }
 232
 233 int ad_dtruncate(struct adouble *ad, const off_t size)
 234 {
 235     if (sys_ftruncate(ad_data_fileno(ad), size) < 0)
 236         return -1;
 237
 238     return 0;
 239 }