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, "Netatalk        ", 16);
 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 || len != add->ad_eid[ eid ].ade_len)
 221             continue;
 222
 223         switch (eid) {
 224         case ADEID_COMMENT:
 225         case ADEID_PRIVDEV:
 226         case ADEID_PRIVINO:
 227         case ADEID_PRIVSYN:
 228         case ADEID_PRIVID:
 229             continue;
 230         default:
 231             ad_setentrylen( add, eid, len );
 232             memcpy( ad_entry( add, eid ), ad_entry( ads, eid ), len );
 233         }
 234     }
 235     add->ad_rlen = ads->ad_rlen;
 236
 237     if (((ads->ad_vers == AD_VERSION2) && (add->ad_vers == AD_VERSION_EA))
 238         || ((ads->ad_vers == AD_VERSION_EA) && (add->ad_vers == AD_VERSION2))) {
 239         cnid_t id;
 240         memcpy(&id, ad_entry(add, ADEID_PRIVID), sizeof(cnid_t));
 241         id = htonl(id);
 242         memcpy(ad_entry(add, ADEID_PRIVID), &id, sizeof(cnid_t));
 243     }
 244     return 0;
 245 }
 246
 247 static int ad_flush_hf(struct adouble *ad)
 248 {
 249     EC_INIT;
 250     int len;
 251     int cwd = -1;
 252
 253     LOG(log_debug, logtype_ad, "ad_flush_hf(%s)", adflags2logstr(ad->ad_adflags));
 254
 255     struct ad_fd *adf;
 256
 257     switch (ad->ad_vers) {
 258     case AD_VERSION2:
 259         adf = ad->ad_mdp;
 260         break;
 261     case AD_VERSION_EA:
 262         adf = &ad->ad_data_fork;
 263         break;
 264     default:
 265         LOG(log_error, logtype_ad, "ad_flush: unexpected adouble version");
 266         return -1;
 267     }
 268
 269     if ((adf->adf_flags & O_RDWR)
 270         || ((ad->ad_adflags & ADFLAGS_DIR) && (ad->ad_adflags & ADFLAGS_RDWR))) {
 271         if (ad_getentryoff(ad, ADEID_RFORK)) {
 272             if (ad->ad_rlen > 0xffffffff)
 273                 ad_setentrylen(ad, ADEID_RFORK, 0xffffffff);
 274             else
 275                 ad_setentrylen(ad, ADEID_RFORK, ad->ad_rlen);
 276         }
 277         len = ad->ad_ops->ad_rebuild_header(ad);
 278
 279         switch (ad->ad_vers) {
 280         case AD_VERSION2:
 281             if (adf_pwrite(ad->ad_mdp, ad->ad_data, len, 0) != len) {
 282                 if (errno == 0)
 283                     errno = EIO;
 284                 return( -1 );
 285             }
 286             break;
 287         case AD_VERSION_EA:
 288             if (AD_META_OPEN(ad)) {
 289                 if (ad->ad_adflags & ADFLAGS_DIR) {
 290                     EC_NEG1_LOG( cwd = open(".", O_RDONLY) );
 291                     EC_NEG1_LOG( fchdir(ad_data_fileno(ad)) );
 292                     EC_ZERO_LOGSTR( sys_lsetxattr(".", AD_EA_META, ad->ad_data, AD_DATASZ_EA, 0),
 293                                     "sys_lsetxattr(\"%s\"): %s", fullpathname(".") ,strerror(errno));
 294                     EC_NEG1_LOG( fchdir(cwd) );
 295                     EC_NEG1_LOG( close(cwd) );
 296                     cwd = -1;
 297                 } else {
 298                     EC_ZERO_LOG( sys_fsetxattr(ad_data_fileno(ad), AD_EA_META, ad->ad_data, AD_DATASZ_EA, 0) );
 299                 }
 300             }
 301             break;
 302         default:
 303             LOG(log_error, logtype_ad, "ad_flush: unexpected adouble version");
 304             return -1;
 305         }
 306     }
 307
 308 EC_CLEANUP:
 309     if (cwd != -1) {
 310         if (fchdir(cwd) != 0) {
 311             AFP_PANIC("ad_flush: cant fchdir");
 312         }
 313         close(cwd);
 314     }
 315     EC_EXIT;
 316 }
 317
 318 /* Flush resofork adouble file if any (currently adouble:ea and #ifndef HAVE_EAFD eg Linux) */
 319 static int ad_flush_rf(struct adouble *ad)
 320 {
 321     ssize_t len;
 322     char    adbuf[AD_DATASZ_OSX];
 323
 324 #ifdef HAVE_EAFD
 325     return 0;
 326 #endif
 327     if (ad->ad_vers != AD_VERSION_EA)
 328         return 0;
 329
 330     LOG(log_debug, logtype_ad, "ad_flush_rf(%s)", adflags2logstr(ad->ad_adflags));
 331
 332     if ((ad->ad_rfp->adf_flags & O_RDWR)) {
 333         if (ad_getentryoff(ad, ADEID_RFORK)) {
 334             if (ad->ad_rlen > 0xffffffff)
 335                 ad_setentrylen(ad, ADEID_RFORK, 0xffffffff);
 336             else
 337                 ad_setentrylen(ad, ADEID_RFORK, ad->ad_rlen);
 338         }
 339         len = ad_rebuild_adouble_header_osx(ad, &adbuf[0]);
 340
 341         if (adf_pwrite(ad->ad_rfp, adbuf, len, 0) != len) {
 342             if (errno == 0)
 343                 errno = EIO;
 344             return -1;
 345         }
 346     }
 347     return 0;
 348 }
 349
 350 int ad_flush(struct adouble *ad)
 351 {
 352     EC_INIT;
 353
 354     LOG(log_debug, logtype_ad, "ad_flush(%s)", adflags2logstr(ad->ad_adflags));
 355
 356     if (AD_META_OPEN(ad)) {
 357         EC_ZERO( ad_flush_hf(ad) );
 358     }
 359
 360     if (AD_RSRC_OPEN(ad)) {
 361         EC_ZERO( ad_flush_rf(ad) );
 362     }
 363
 364 EC_CLEANUP:
 365     EC_EXIT;
 366 }
 367
 368 static int ad_data_closefd(struct adouble *ad)
 369 {
 370     int ret = 0;
 371
 372     if (ad_data_fileno(ad) == AD_SYMLINK) {
 373         free(ad->ad_data_fork.adf_syml);
 374         ad->ad_data_fork.adf_syml = NULL;
 375     } else {
 376         if (close(ad_data_fileno(ad)) < 0)
 377             ret = -1;
 378     }
 379     ad_data_fileno(ad) = -1;
 380     return ret;
 381 }
 382
 383 /*!
 384  * Close a struct adouble freeing all resources
 385  */
 386 int ad_close(struct adouble *ad, int adflags)
 387 {
 388     int err = 0;
 389
 390     if (ad == NULL)
 391         return err;
 392
 393
 394     LOG(log_debug, logtype_ad,
 395         "ad_close(%s): BEGIN: {d: %d, m: %d, r: %d} "
 396         "[dfd: %d (ref: %d), mfd: %d (ref: %d), rfd: %d (ref: %d)]",
 397         adflags2logstr(adflags),
 398         ad->ad_data_refcount, ad->ad_meta_refcount, ad->ad_reso_refcount,
 399         ad_data_fileno(ad), ad->ad_data_fork.adf_refcount,
 400         ad_meta_fileno(ad), ad->ad_mdp->adf_refcount,
 401         ad_reso_fileno(ad), ad->ad_rfp->adf_refcount);
 402
 403     if (adflags & (ADFLAGS_SETSHRMD | ADFLAGS_CHECK_OF)) {
 404         /* sharemode locks are stored in the data fork, adouble:v2 needs this extra handling */
 405         adflags |= ADFLAGS_DF;
 406     }
 407
 408     if ((ad->ad_vers == AD_VERSION2) && (adflags & ADFLAGS_RF))
 409         adflags |= ADFLAGS_HF;
 410
 411     if ((adflags & ADFLAGS_DF) && (ad_data_fileno(ad) >= 0 || ad_data_fileno(ad) == AD_SYMLINK)) {
 412         if (ad->ad_data_refcount)
 413             if (--ad->ad_data_refcount == 0)
 414                 adf_lock_free(&ad->ad_data_fork);
 415         if (--ad->ad_data_fork.adf_refcount == 0) {
 416             if (ad_data_closefd(ad) < 0)
 417                 err = -1;
 418         }
 419     }
 420
 421     if ((adflags & ADFLAGS_HF) && (ad_meta_fileno(ad) != -1)) {
 422         if (ad->ad_meta_refcount)
 423             ad->ad_meta_refcount--;
 424         if (!(--ad->ad_mdp->adf_refcount)) {
 425             if (close( ad_meta_fileno(ad)) < 0)
 426                 err = -1;
 427             ad_meta_fileno(ad) = -1;
 428         }
 429     }
 430
 431     if (adflags & ADFLAGS_RF) {
 432         /* HF is automatically opened when opening an RF, close it. */
 433         if ((ad->ad_vers == AD_VERSION2) && (ad_meta_fileno(ad) != -1)) {
 434             if (ad->ad_meta_refcount)
 435                 ad->ad_meta_refcount--;
 436             if (!(--ad->ad_mdp->adf_refcount)) {
 437                 if (close( ad_meta_fileno(ad)) < 0)
 438                     err = -1;
 439                 ad_meta_fileno(ad) = -1;
 440             }
 441         }
 442
 443         if (ad->ad_reso_refcount)
 444             if (--ad->ad_reso_refcount == 0)
 445                 adf_lock_free(ad->ad_rfp);
 446         if (ad->ad_vers == AD_VERSION_EA) {
 447             if ((ad_reso_fileno(ad) != -1)
 448                 && !(--ad->ad_rfp->adf_refcount)) {
 449                 if (close(ad->ad_rfp->adf_fd) < 0)
 450                     err = -1;
 451                 ad->ad_rlen = 0;
 452                 ad_reso_fileno(ad) = -1;
 453             }
 454         }
 455     }
 456
 457     LOG(log_debug, logtype_ad,
 458         "ad_close(%s): END: %d {d: %d, m: %d, r: %d} "
 459         "[dfd: %d (ref: %d), mfd: %d (ref: %d), rfd: %d (ref: %d)]",
 460         adflags2logstr(adflags), err,
 461         ad->ad_data_refcount, ad->ad_meta_refcount, ad->ad_reso_refcount,
 462         ad_data_fileno(ad), ad->ad_data_fork.adf_refcount,
 463         ad_meta_fileno(ad), ad->ad_mdp->adf_refcount,
 464         ad_reso_fileno(ad), ad->ad_rfp->adf_refcount);
 465
 466     return err;
 467 }