libatalk/adouble/ad_flush.c

   1 /*
   2  * Copyright (c) 1990,1991 Regents of The University of Michigan.
   3  * Copyright (c) 2010      Frank Lahm
   4  * All Rights Reserved.
   5  *
   6  * Permission to use, copy, modify, and distribute this software and
   7  * its documentation for any purpose and without fee is hereby granted,
   8  * provided that the above copyright notice appears in all copies and
   9  * that both that copyright notice and this permission notice appear
  10  * in supporting documentation, and that the name of The University
  11  * of Michigan not be used in advertising or publicity pertaining to
  12  * distribution of the software without specific, written prior
  13  * permission. This software is supplied as is without expressed or
  14  * implied warranties of any kind.
  15  *
  16  *  Research Systems Unix Group
  17  *  The University of Michigan
  18  *  c/o Mike Clark
  19  *  535 W. William Street
  20  *  Ann Arbor, Michigan
  21  *  +1-313-763-0525
  22  *  netatalk@itd.umich.edu
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif /* HAVE_CONFIG_H */
  28
  29 #include <string.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <errno.h>
  33 #include <arpa/inet.h>
  34
  35 #include <atalk/adouble.h>
  36 #include <atalk/ea.h>
  37 #include <atalk/logger.h>
  38 #include <atalk/bstrlib.h>
  39 #include <atalk/bstradd.h>
  40 #include <atalk/errchk.h>
  41 #include <atalk/util.h>
  42
  43 #include "ad_lock.h"
  44
  45 static const uint32_t set_eid[] = {
  46     0,1,2,3,4,5,6,7,8,
  47     9,10,11,12,13,14,15,
  48     AD_DEV, AD_INO, AD_SYN, AD_ID
  49 };
  50
  51 #define EID_DISK(a) (set_eid[a])
  52
  53 /*
  54  * Prepare ad->ad_data buffer from struct adouble for writing on disk
  55  */
  56 int ad_rebuild_adouble_header_v2(struct adouble *ad)
  57 {
  58     uint32_t       eid;
  59     uint32_t       temp;
  60     uint16_t       nent;
  61     char        *buf, *nentp;
  62
  63     LOG(log_debug, logtype_ad, "ad_rebuild_adouble_header_v2");
  64
  65     buf = ad->ad_data;
  66
  67     temp = htonl( ad->ad_magic );
  68     memcpy(buf, &temp, sizeof( temp ));
  69     buf += sizeof( temp );
  70
  71     temp = htonl( ad->ad_version );
  72     memcpy(buf, &temp, sizeof( temp ));
  73     buf += sizeof( temp );
  74
  75     buf += sizeof( ad->ad_filler );
  76
  77     nentp = buf;
  78     buf += sizeof( nent );
  79     for ( eid = 0, nent = 0; eid < ADEID_MAX; eid++ ) {
  80         if (ad->ad_eid[ eid ].ade_off == 0)
  81             continue;
  82         temp = htonl( EID_DISK(eid) );
  83         memcpy(buf, &temp, sizeof( temp ));
  84         buf += sizeof( temp );
  85
  86         temp = htonl( ad->ad_eid[ eid ].ade_off );
  87         memcpy(buf, &temp, sizeof( temp ));
  88         buf += sizeof( temp );
  89
  90         temp = htonl( ad->ad_eid[ eid ].ade_len );
  91         memcpy(buf, &temp, sizeof( temp ));
  92         buf += sizeof( temp );
  93         nent++;
  94     }
  95     nent = htons( nent );
  96     memcpy(nentp, &nent, sizeof( nent ));
  97
  98     return ad_getentryoff(ad, ADEID_RFORK);
  99 }
 100
 101 int ad_rebuild_adouble_header_ea(struct adouble *ad)
 102 {
 103     uint32_t       eid;
 104     uint32_t       temp;
 105     uint16_t       nent;
 106     char        *buf, *nentp;
 107
 108     LOG(log_debug, logtype_ad, "ad_rebuild_adouble_header_ea");
 109
 110     buf = ad->ad_data;
 111
 112     temp = htonl( ad->ad_magic );
 113     memcpy(buf, &temp, sizeof( temp ));
 114     buf += sizeof( temp );
 115
 116     temp = htonl( ad->ad_version );
 117     memcpy(buf, &temp, sizeof( temp ));
 118     buf += sizeof( temp );
 119
 120     buf += sizeof( ad->ad_filler );
 121
 122     nentp = buf;
 123     buf += sizeof( nent );
 124     for ( eid = 0, nent = 0; eid < ADEID_MAX; eid++ ) {
 125         if ((ad->ad_eid[ eid ].ade_off == 0) || (eid == ADEID_RFORK))
 126             continue;
 127         temp = htonl( EID_DISK(eid) );
 128         memcpy(buf, &temp, sizeof( temp ));
 129         buf += sizeof( temp );
 130
 131         temp = htonl( ad->ad_eid[ eid ].ade_off );
 132         memcpy(buf, &temp, sizeof( temp ));
 133         buf += sizeof( temp );
 134
 135         temp = htonl( ad->ad_eid[ eid ].ade_len );
 136         memcpy(buf, &temp, sizeof( temp ));
 137         buf += sizeof( temp );
 138         nent++;
 139     }
 140     nent = htons( nent );
 141     memcpy(nentp, &nent, sizeof( nent ));
 142
 143     return AD_DATASZ_EA;
 144 }
 145
 146 /*!
 147  * Prepare adbuf buffer from struct adouble for writing on disk
 148  */
 149 int ad_rebuild_adouble_header_osx(struct adouble *ad, char *adbuf)
 150 {
 151     uint32_t       temp;
 152     uint16_t       nent;
 153     char           *buf;
 154
 155     LOG(log_debug, logtype_ad, "ad_rebuild_adouble_header_osx");
 156
 157     buf = &adbuf[0];
 158
 159     temp = htonl( ad->ad_magic );
 160     memcpy(buf, &temp, sizeof( temp ));
 161     buf += sizeof( temp );
 162
 163     temp = htonl( ad->ad_version );
 164     memcpy(buf, &temp, sizeof( temp ));
 165     buf += sizeof( temp );
 166
 167     memcpy(buf, AD_FILLER_NETATALK, strlen(AD_FILLER_NETATALK));
 168     buf += sizeof( ad->ad_filler );
 169
 170     nent = htons(ADEID_NUM_OSX);
 171     memcpy(buf, &nent, sizeof( nent ));
 172     buf += sizeof( nent );
 173
 174     /* FinderInfo */
 175     temp = htonl(EID_DISK(ADEID_FINDERI));
 176     memcpy(buf, &temp, sizeof( temp ));
 177     buf += sizeof( temp );
 178
 179     temp = htonl(ADEDOFF_FINDERI_OSX);
 180     memcpy(buf, &temp, sizeof( temp ));
 181     buf += sizeof( temp );
 182
 183     temp = htonl(ADEDLEN_FINDERI);
 184     memcpy(buf, &temp, sizeof( temp ));
 185     buf += sizeof( temp );
 186
 187     memcpy(adbuf + ADEDOFF_FINDERI_OSX, ad_entry(ad, ADEID_FINDERI), ADEDLEN_FINDERI);
 188
 189     /* rfork */
 190     temp = htonl( EID_DISK(ADEID_RFORK) );
 191     memcpy(buf, &temp, sizeof( temp ));
 192     buf += sizeof( temp );
 193
 194     temp = htonl(ADEDOFF_RFORK_OSX);
 195     memcpy(buf, &temp, sizeof( temp ));
 196     buf += sizeof( temp );
 197
 198     temp = htonl( ad->ad_rlen);
 199     memcpy(buf, &temp, sizeof( temp ));
 200     buf += sizeof( temp );
 201
 202     return AD_DATASZ_OSX;
 203 }
 204
 205 /* -------------------
 206  * XXX copy only header with same size or comment
 207  * doesn't work well for adouble with different version.
 208  *
 209  */
 210 int ad_copy_header(struct adouble *add, struct adouble *ads)
 211 {
 212     uint32_t       eid;
 213     uint32_t       len;
 214
 215     for ( eid = 0; eid < ADEID_MAX; eid++ ) {
 216         if ( ads->ad_eid[ eid ].ade_off == 0 || add->ad_eid[ eid ].ade_off == 0 )
 217             continue;
 218
 219         len = ads->ad_eid[ eid ].ade_len;
 220         if (len == 0)
 221             continue;
 222
 223         switch (eid) {
 224         case ADEID_COMMENT:
 225         case ADEID_RFORK:
 226             continue;
 227         default:
 228             ad_setentrylen( add, eid, len );
 229             memcpy( ad_entry( add, eid ), ad_entry( ads, eid ), len );
 230         }
 231     }
 232     add->ad_rlen = ads->ad_rlen;
 233
 234     if (((ads->ad_vers == AD_VERSION2) && (add->ad_vers == AD_VERSION_EA))
 235         || ((ads->ad_vers == AD_VERSION_EA) && (add->ad_vers == AD_VERSION2))) {
 236         cnid_t id;
 237         memcpy(&id, ad_entry(add, ADEID_PRIVID), sizeof(cnid_t));
 238         id = htonl(id);
 239         memcpy(ad_entry(add, ADEID_PRIVID), &id, sizeof(cnid_t));
 240     }
 241     return 0;
 242 }
 243
 244 static int ad_flush_hf(struct adouble *ad)
 245 {
 246     EC_INIT;
 247     int len;
 248     int cwd = -1;
 249
 250     LOG(log_debug, logtype_ad, "ad_flush_hf(%s)", adflags2logstr(ad->ad_adflags));
 251
 252     struct ad_fd *adf;
 253
 254     switch (ad->ad_vers) {
 255     case AD_VERSION2:
 256         adf = ad->ad_mdp;
 257         break;
 258     case AD_VERSION_EA:
 259         adf = &ad->ad_data_fork;
 260         break;
 261     default:
 262         LOG(log_error, logtype_ad, "ad_flush: unexpected adouble version");
 263         return -1;
 264     }
 265
 266     if ((adf->adf_flags & O_RDWR)
 267         || ((ad->ad_adflags & ADFLAGS_DIR) && (ad->ad_adflags & ADFLAGS_RDWR))) {
 268         if (ad_getentryoff(ad, ADEID_RFORK)) {
 269             if (ad->ad_rlen > 0xffffffff)
 270                 ad_setentrylen(ad, ADEID_RFORK, 0xffffffff);
 271             else
 272                 ad_setentrylen(ad, ADEID_RFORK, ad->ad_rlen);
 273         }
 274         len = ad->ad_ops->ad_rebuild_header(ad);
 275
 276         switch (ad->ad_vers) {
 277         case AD_VERSION2:
 278             if (adf_pwrite(ad->ad_mdp, ad->ad_data, len, 0) != len) {
 279                 if (errno == 0)
 280                     errno = EIO;
 281                 return( -1 );
 282             }
 283             break;
 284         case AD_VERSION_EA:
 285             if (AD_META_OPEN(ad)) {
 286                 if (ad->ad_adflags & ADFLAGS_DIR) {
 287                     EC_NEG1_LOG( cwd = open(".", O_RDONLY) );
 288                     EC_NEG1_LOG( fchdir(ad_data_fileno(ad)) );
 289                     EC_ZERO_LOGSTR( sys_lsetxattr(".", AD_EA_META, ad->ad_data, AD_DATASZ_EA, 0),
 290                                     "sys_lsetxattr(\"%s\"): %s", fullpathname(".") ,strerror(errno));
 291                     EC_NEG1_LOG( fchdir(cwd) );
 292                     EC_NEG1_LOG( close(cwd) );
 293                     cwd = -1;
 294                 } else {
 295                     EC_ZERO_LOG( sys_fsetxattr(ad_data_fileno(ad), AD_EA_META, ad->ad_data, AD_DATASZ_EA, 0) );
 296                 }
 297             }
 298             break;
 299         default:
 300             LOG(log_error, logtype_ad, "ad_flush: unexpected adouble version");
 301             return -1;
 302         }
 303     }
 304
 305 EC_CLEANUP:
 306     if (cwd != -1) {
 307         if (fchdir(cwd) != 0) {
 308             AFP_PANIC("ad_flush: cant fchdir");
 309         }
 310         close(cwd);
 311     }
 312     EC_EXIT;
 313 }
 314
 315 /* Flush resofork adouble file if any (currently adouble:ea and #ifndef HAVE_EAFD eg Linux) */
 316 static int ad_flush_rf(struct adouble *ad)
 317 {
 318     ssize_t len;
 319     char    adbuf[AD_DATASZ_OSX];
 320
 321 #ifdef HAVE_EAFD
 322     return 0;
 323 #endif
 324     if (ad->ad_vers != AD_VERSION_EA)
 325         return 0;
 326
 327     LOG(log_debug, logtype_ad, "ad_flush_rf(%s)", adflags2logstr(ad->ad_adflags));
 328
 329     if ((ad->ad_rfp->adf_flags & O_RDWR)) {
 330         if (ad_getentryoff(ad, ADEID_RFORK)) {
 331             if (ad->ad_rlen > 0xffffffff)
 332                 ad_setentrylen(ad, ADEID_RFORK, 0xffffffff);
 333             else
 334                 ad_setentrylen(ad, ADEID_RFORK, ad->ad_rlen);
 335         }
 336         len = ad_rebuild_adouble_header_osx(ad, &adbuf[0]);
 337
 338         if (adf_pwrite(ad->ad_rfp, adbuf, len, 0) != len) {
 339             if (errno == 0)
 340                 errno = EIO;
 341             return -1;
 342         }
 343     }
 344     return 0;
 345 }
 346
 347 int ad_flush(struct adouble *ad)
 348 {
 349     EC_INIT;
 350
 351     LOG(log_debug, logtype_ad, "ad_flush(%s)", adflags2logstr(ad->ad_adflags));
 352
 353     if (AD_META_OPEN(ad)) {
 354         EC_ZERO( ad_flush_hf(ad) );
 355     }
 356
 357     if (AD_RSRC_OPEN(ad)) {
 358         EC_ZERO( ad_flush_rf(ad) );
 359     }
 360
 361 EC_CLEANUP:
 362     EC_EXIT;
 363 }
 364
 365 static int ad_data_closefd(struct adouble *ad)
 366 {
 367     int ret = 0;
 368
 369     if (ad_data_fileno(ad) == AD_SYMLINK) {
 370         free(ad->ad_data_fork.adf_syml);
 371         ad->ad_data_fork.adf_syml = NULL;
 372     } else {
 373         if (close(ad_data_fileno(ad)) < 0)
 374             ret = -1;
 375     }
 376     ad_data_fileno(ad) = -1;
 377     return ret;
 378 }
 379
 380 /*!
 381  * Close a struct adouble freeing all resources
 382  */
 383 int ad_close(struct adouble *ad, int adflags)
 384 {
 385     int err = 0;
 386
 387     if (ad == NULL)
 388         return err;
 389
 390
 391     LOG(log_debug, logtype_ad,
 392         "ad_close(%s): BEGIN: {d: %d, m: %d, r: %d} "
 393         "[dfd: %d (ref: %d), mfd: %d (ref: %d), rfd: %d (ref: %d)]",
 394         adflags2logstr(adflags),
 395         ad->ad_data_refcount, ad->ad_meta_refcount, ad->ad_reso_refcount,
 396         ad_data_fileno(ad), ad->ad_data_fork.adf_refcount,
 397         ad_meta_fileno(ad), ad->ad_mdp->adf_refcount,
 398         ad_reso_fileno(ad), ad->ad_rfp->adf_refcount);
 399
 400     if (adflags & (ADFLAGS_SETSHRMD | ADFLAGS_CHECK_OF)) {
 401         /* sharemode locks are stored in the data fork, adouble:v2 needs this extra handling */
 402         adflags |= ADFLAGS_DF;
 403     }
 404
 405     if ((ad->ad_vers == AD_VERSION2) && (adflags & ADFLAGS_RF))
 406         adflags |= ADFLAGS_HF;
 407
 408     if ((adflags & ADFLAGS_DF) && (ad_data_fileno(ad) >= 0 || ad_data_fileno(ad) == AD_SYMLINK)) {
 409         if (ad->ad_data_refcount)
 410             if (--ad->ad_data_refcount == 0)
 411                 adf_lock_free(&ad->ad_data_fork);
 412         if (--ad->ad_data_fork.adf_refcount == 0) {
 413             if (ad_data_closefd(ad) < 0)
 414                 err = -1;
 415         }
 416     }
 417
 418     if ((adflags & ADFLAGS_HF) && (ad_meta_fileno(ad) != -1)) {
 419         if (ad->ad_meta_refcount)
 420             ad->ad_meta_refcount--;
 421         if (!(--ad->ad_mdp->adf_refcount)) {
 422             if (close( ad_meta_fileno(ad)) < 0)
 423                 err = -1;
 424             ad_meta_fileno(ad) = -1;
 425         }
 426     }
 427
 428     if (adflags & ADFLAGS_RF) {
 429         /* HF is automatically opened when opening an RF, close it. */
 430         if ((ad->ad_vers == AD_VERSION2) && (ad_meta_fileno(ad) != -1)) {
 431             if (ad->ad_meta_refcount)
 432                 ad->ad_meta_refcount--;
 433             if (!(--ad->ad_mdp->adf_refcount)) {
 434                 if (close( ad_meta_fileno(ad)) < 0)
 435                     err = -1;
 436                 ad_meta_fileno(ad) = -1;
 437             }
 438         }
 439
 440         if (ad->ad_reso_refcount)
 441             if (--ad->ad_reso_refcount == 0)
 442                 adf_lock_free(ad->ad_rfp);
 443         if (ad->ad_vers == AD_VERSION_EA) {
 444             if ((ad_reso_fileno(ad) != -1)
 445                 && !(--ad->ad_rfp->adf_refcount)) {
 446                 if (close(ad->ad_rfp->adf_fd) < 0)
 447                     err = -1;
 448                 ad->ad_rlen = 0;
 449                 ad_reso_fileno(ad) = -1;
 450             }
 451         }
 452     }
 453
 454     LOG(log_debug, logtype_ad,
 455         "ad_close(%s): END: %d {d: %d, m: %d, r: %d} "
 456         "[dfd: %d (ref: %d), mfd: %d (ref: %d), rfd: %d (ref: %d)]",
 457         adflags2logstr(adflags), err,
 458         ad->ad_data_refcount, ad->ad_meta_refcount, ad->ad_reso_refcount,
 459         ad_data_fileno(ad), ad->ad_data_fork.adf_refcount,
 460         ad_meta_fileno(ad), ad->ad_mdp->adf_refcount,
 461         ad_reso_fileno(ad), ad->ad_rfp->adf_refcount);
 462
 463     return err;
 464 }