libatalk/adouble/ad_open.c

   1 /*
   2  * $Id: ad_open.c,v 1.30.6.18.2.8 2008-11-25 15:16:33 didg Exp $
   3  *
   4  * Copyright (c) 1999 Adrian Sun (asun@u.washington.edu)
   5  * Copyright (c) 1990,1991 Regents of The University of Michigan.
   6  * All Rights Reserved.
   7  *
   8  * Permission to use, copy, modify, and distribute this software and
   9  * its documentation for any purpose and without fee is hereby granted,
  10  * provided that the above copyright notice appears in all copies and
  11  * that both that copyright notice and this permission notice appear
  12  * in supporting documentation, and that the name of The University
  13  * of Michigan not be used in advertising or publicity pertaining to
  14  * distribution of the software without specific, written prior
  15  * permission. This software is supplied as is without expressed or
  16  * implied warranties of any kind.
  17  *
  18  *      Research Systems Unix Group
  19  *      The University of Michigan
  20  *      c/o Mike Clark
  21  *      535 W. William Street
  22  *      Ann Arbor, Michigan
  23  *      +1-313-763-0525
  24  *      netatalk@itd.umich.edu
  25  *
  26  * NOTE: I don't use inline because a good compiler should be
  27  * able to optimize all the static below. Didier
  28  */
  29
  30 #ifdef HAVE_CONFIG_H
  31 #include "config.h"
  32 #endif /* HAVE_CONFIG_H */
  33
  34 #include <errno.h>
  35
  36 #include <atalk/adouble.h>
  37 #include <sys/param.h>
  38 #include <atalk/logger.h>
  39
  40 #include <atalk/util.h>
  41 #include <string.h>
  42
  43 #include "ad_private.h"
  44 #include <stdlib.h>
  45
  46 #ifndef MAX
  47 #define MAX(a, b)  ((a) < (b) ? (b) : (a))
  48 #endif /* ! MAX */
  49
  50 /*
  51  * AppleDouble entry default offsets.
  52  * The layout looks like this:
  53  *
  54  * this is the v1 layout:
  55  *        255     200             16      32              N
  56  *      |  NAME |    COMMENT    | FILEI |    FINDERI    | RFORK |
  57  *
  58  * we need to change it to look like this:
  59  *
  60  * v2 layout:
  61  * field       length (in bytes)
  62  * NAME        255
  63  * COMMENT     200
  64  * FILEDATESI  16     replaces FILEI
  65  * FINDERI     32
  66  * DID          4     new
  67  * AFPFILEI     4     new
  68  * SHORTNAME   12     8.3 new
  69  * RFORK        N
  70  *
  71  * so, all we need to do is replace FILEI with FILEDATESI, move RFORK,
  72  * and add in the new fields.
  73  *
  74  * NOTE: the HFS module will need similar modifications to interact with
  75  * afpd correctly.
  76  */
  77
  78 #define ADEDOFF_MAGIC        (0)
  79 #define ADEDOFF_VERSION      (ADEDOFF_MAGIC + ADEDLEN_MAGIC)
  80 #define ADEDOFF_FILLER       (ADEDOFF_VERSION + ADEDLEN_VERSION)
  81 #define ADEDOFF_NENTRIES     (ADEDOFF_FILLER + ADEDLEN_FILLER)
  82
  83 /* initial lengths of some of the fields */
  84 #define ADEDLEN_INIT     0
  85
  86 /* make sure we don't redefine ADEDOFF_FILEI */
  87 #ifdef ADEDOFF_FILEI
  88 #undef ADEDOFF_FILEI
  89 #endif /* ADEDOFF_FILEI */
  90
  91 #define ADEDOFF_NAME_V1      (AD_HEADER_LEN + ADEID_NUM_V1*AD_ENTRY_LEN)
  92 #define ADEDOFF_COMMENT_V1   (ADEDOFF_NAME_V1 + ADEDLEN_NAME)
  93 #define ADEDOFF_FILEI        (ADEDOFF_COMMENT_V1 + ADEDLEN_COMMENT)
  94 #define ADEDOFF_FINDERI_V1   (ADEDOFF_FILEI + ADEDLEN_FILEI)
  95 #define ADEDOFF_RFORK_V1     (ADEDOFF_FINDERI_V1 + ADEDLEN_FINDERI)
  96
  97 /* i stick things in a slightly different order than their eid order in
  98  * case i ever want to separate RootInfo behaviour from the rest of the
  99  * stuff. */
 100 #define ADEDOFF_NAME_V2      (AD_HEADER_LEN + ADEID_NUM_V2*AD_ENTRY_LEN)
 101 #define ADEDOFF_COMMENT_V2   (ADEDOFF_NAME_V2 + ADEDLEN_NAME)
 102 #define ADEDOFF_FILEDATESI   (ADEDOFF_COMMENT_V2 + ADEDLEN_COMMENT)
 103 #define ADEDOFF_FINDERI_V2   (ADEDOFF_FILEDATESI + ADEDLEN_FILEDATESI)
 104 #define ADEDOFF_DID          (ADEDOFF_FINDERI_V2 + ADEDLEN_FINDERI)
 105 #define ADEDOFF_AFPFILEI     (ADEDOFF_DID + ADEDLEN_DID)
 106 #define ADEDOFF_SHORTNAME    (ADEDOFF_AFPFILEI + ADEDLEN_AFPFILEI)
 107 #define ADEDOFF_PRODOSFILEI  (ADEDOFF_SHORTNAME + ADEDLEN_SHORTNAME)
 108 #define ADEDOFF_PRIVDEV      (ADEDOFF_PRODOSFILEI + ADEDLEN_PRODOSFILEI)
 109 #define ADEDOFF_PRIVINO      (ADEDOFF_PRIVDEV + ADEDLEN_PRIVDEV)
 110 #define ADEDOFF_PRIVSYN      (ADEDOFF_PRIVINO + ADEDLEN_PRIVINO)
 111 #define ADEDOFF_PRIVID       (ADEDOFF_PRIVSYN + ADEDLEN_PRIVSYN)
 112
 113 #define ADEDOFF_RFORK_V2     (ADEDOFF_PRIVID + ADEDLEN_PRIVID)
 114
 115 #define ADEID_NUM_OSX        2
 116 #define ADEDOFF_FINDERI_OSX  (AD_HEADER_LEN + ADEID_NUM_OSX*AD_ENTRY_LEN)
 117 #define ADEDOFF_RFORK_OSX    (ADEDOFF_FINDERI_OSX + ADEDLEN_FINDERI)
 118
 119 /* we keep local copies of a bunch of stuff so that we can initialize things
 120  * correctly. */
 121
 122 /* invisible bit for dot files */
 123 #define ATTRBIT_INVISIBLE     (1 << 0)
 124
 125 /* this is to prevent changing timezones from causing problems with
 126    localtime volumes. the screw-up is 30 years. we use a delta of 5
 127    years.  */
 128 #define TIMEWARP_DELTA 157680000
 129
 130
 131 struct entry {
 132   u_int32_t id, offset, len;
 133 };
 134
 135 static const struct entry entry_order1[ADEID_NUM_V1 +1] = {
 136   {ADEID_NAME,    ADEDOFF_NAME_V1,    ADEDLEN_INIT},      /* 3 */
 137   {ADEID_COMMENT, ADEDOFF_COMMENT_V1, ADEDLEN_INIT},      /* 4 */
 138   {ADEID_FILEI,   ADEDOFF_FILEI,      ADEDLEN_FILEI},     /* 7 */
 139   {ADEID_FINDERI, ADEDOFF_FINDERI_V1, ADEDLEN_FINDERI},   /* 9 */
 140   {ADEID_RFORK,   ADEDOFF_RFORK_V1,   ADEDLEN_INIT},      /* 2 */
 141   {0, 0, 0}
 142 };
 143
 144 #if AD_VERSION == AD_VERSION1
 145 #define DISK_EID(ad, a) (a)
 146
 147 #else /* AD_VERSION == AD_VERSION2 */
 148
 149 static u_int32_t get_eid(struct adouble *ad, u_int32_t eid)
 150 {
 151     if (eid <= 15)
 152         return eid;
 153     if (ad->ad_version == AD_VERSION1)
 154         return 0;
 155     if (eid == AD_DEV)
 156         return ADEID_PRIVDEV;
 157     if (eid == AD_INO)
 158         return ADEID_PRIVINO;
 159     if (eid == AD_SYN)
 160         return ADEID_PRIVSYN;
 161     if (eid == AD_ID)
 162         return ADEID_PRIVID;
 163
 164     return 0;
 165 }
 166
 167 #define DISK_EID(ad, a) get_eid(ad, a)
 168
 169 static const struct entry entry_order2[ADEID_NUM_V2 +1] = {
 170   {ADEID_NAME, ADEDOFF_NAME_V2, ADEDLEN_INIT},
 171   {ADEID_COMMENT, ADEDOFF_COMMENT_V2, ADEDLEN_INIT},
 172   {ADEID_FILEDATESI, ADEDOFF_FILEDATESI, ADEDLEN_FILEDATESI},
 173   {ADEID_FINDERI, ADEDOFF_FINDERI_V2, ADEDLEN_FINDERI},
 174   {ADEID_DID, ADEDOFF_DID, ADEDLEN_DID},
 175   {ADEID_AFPFILEI, ADEDOFF_AFPFILEI, ADEDLEN_AFPFILEI},
 176   {ADEID_SHORTNAME, ADEDOFF_SHORTNAME, ADEDLEN_INIT},
 177   {ADEID_PRODOSFILEI, ADEDOFF_PRODOSFILEI, ADEDLEN_PRODOSFILEI},
 178   {ADEID_PRIVDEV,     ADEDOFF_PRIVDEV, ADEDLEN_INIT},
 179   {ADEID_PRIVINO,     ADEDOFF_PRIVINO, ADEDLEN_INIT},
 180   {ADEID_PRIVSYN,     ADEDOFF_PRIVSYN, ADEDLEN_INIT},
 181   {ADEID_PRIVID,     ADEDOFF_PRIVID, ADEDLEN_INIT},
 182   {ADEID_RFORK, ADEDOFF_RFORK_V2, ADEDLEN_INIT},
 183
 184   {0, 0, 0}
 185 };
 186
 187 /* OS X adouble finder info and resource fork only
 188 */
 189 static const struct entry entry_order_osx[ADEID_NUM_OSX +1] = {
 190   {ADEID_FINDERI, ADEDOFF_FINDERI_OSX, ADEDLEN_FINDERI},
 191   {ADEID_RFORK, ADEDOFF_RFORK_OSX, ADEDLEN_INIT},
 192
 193   {0, 0, 0}
 194 };
 195
 196 #endif /* AD_VERSION == AD_VERSION2 */
 197
 198 #if AD_VERSION == AD_VERSION2
 199
 200 /* update a version 2 adouble resource fork with our private entries */
 201 static int ad_update(struct adouble *ad, const char *path)
 202 {
 203   struct stat st;
 204   u_int16_t nentries = 0;
 205   off_t     off, shiftdata=0;
 206   const struct entry  *eid;
 207   static off_t entry_len[ADEID_MAX];
 208   static char  databuf[ADEID_MAX][256], *buf;
 209   int fd;
 210   int ret = -1;
 211
 212   /* check to see if we should convert this header. */
 213   if (!path || ad->ad_flags != AD_VERSION2)
 214     return 0;
 215
 216   if (!(ad->ad_hf.adf_flags & O_RDWR)) {
 217       /* we were unable to open the file read write the last time */
 218       return 0;
 219   }
 220
 221   if (ad->ad_eid[ADEID_RFORK].ade_off) {
 222       shiftdata = ADEDOFF_RFORK_V2 -ad->ad_eid[ADEID_RFORK].ade_off;
 223   }
 224
 225   memcpy(&nentries, ad->ad_data + ADEDOFF_NENTRIES, sizeof( nentries ));
 226   nentries = ntohs( nentries );
 227
 228   if ( shiftdata == 0 && nentries == ADEID_NUM_V2)
 229     return 0;
 230
 231   memset(entry_len, 0, sizeof(entry_len));
 232   memset(databuf, 0, sizeof(databuf));
 233
 234   /* bail if we can't get a lock */
 235   if (ad_tmplock(ad, ADEID_RFORK, ADLOCK_WR, 0, 0, 0) < 0)
 236     goto bail_err;
 237
 238   fd = ad->ad_hf.adf_fd;
 239
 240   if (fstat(fd, &st)) {
 241     goto bail_lock;
 242   }
 243
 244   if (st.st_size > 0x7fffffff) {
 245       LOG(log_debug, logtype_default, "ad_update: file '%s' too big for update.", path);
 246       errno = EIO;
 247       goto bail_lock;
 248   }
 249
 250   off = ad->ad_eid[ADEID_RFORK].ade_off;
 251   if (off > st.st_size) {
 252       LOG(log_error, logtype_default, "ad_update: invalid resource fork offset. (off: %u)", off);
 253       errno = EIO;
 254       goto bail_lock;
 255   }
 256
 257   if (ad->ad_eid[ADEID_RFORK].ade_len > st.st_size - off) {
 258       LOG(log_error, logtype_default, "ad_update: invalid resource fork length. (rfork len: %u)", ad->ad_eid[ADEID_RFORK].ade_len);
 259       errno = EIO;
 260       goto bail_lock;
 261   }
 262
 263   if ((void *) (buf = (char *)
 264                 mmap(NULL, st.st_size + shiftdata,
 265                      PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) ==
 266           MAP_FAILED) {
 267     goto bail_lock;
 268   }
 269
 270   /* last place for failure. */
 271   if (sys_ftruncate(fd, st.st_size + shiftdata) < 0) {
 272     goto bail_lock;
 273   }
 274
 275   /* move the RFORK. this assumes that the RFORK is at the end */
 276   if (off) {
 277     memmove(buf + ADEDOFF_RFORK_V2, buf + off, ad->ad_eid[ADEID_RFORK].ade_len);
 278   }
 279
 280   munmap(buf, st.st_size + shiftdata);
 281
 282   /* now, fix up our copy of the header */
 283   memset(ad->ad_filler, 0, sizeof(ad->ad_filler));
 284
 285   /* save the header entries */
 286   eid = entry_order2;
 287   while (eid->id) {
 288     if( ad->ad_eid[eid->id].ade_off != 0) {
 289       if ( eid->id > 2 && ad->ad_eid[eid->id].ade_len < 256)
 290         memcpy( databuf[eid->id], ad->ad_data +ad->ad_eid[eid->id].ade_off, ad->ad_eid[eid->id].ade_len);
 291       entry_len[eid->id] = ad->ad_eid[eid->id].ade_len;
 292     }
 293     eid++;
 294   }
 295
 296   memset(ad->ad_data + AD_HEADER_LEN, 0, AD_DATASZ - AD_HEADER_LEN);
 297
 298   /* copy the saved entries to the new header */
 299   eid = entry_order2;
 300   while (eid->id) {
 301     if ( eid->id > 2 && entry_len[eid->id] > 0) {
 302       memcpy(ad->ad_data+eid->offset, databuf[eid->id], entry_len[eid->id]);
 303     }
 304     ad->ad_eid[eid->id].ade_off = eid->offset;
 305     ad->ad_eid[eid->id].ade_len = entry_len[eid->id];
 306     eid++;
 307   }
 308
 309   /* rebuild the header and cleanup */
 310   LOG(log_debug, logtype_default, "updated AD2 header %s", path);
 311   ad_flush(ad, ADFLAGS_HF );
 312   ret = 0;
 313
 314 bail_lock:
 315   ad_tmplock(ad, ADEID_RFORK, ADLOCK_CLR, 0, 0, 0);
 316 bail_err:
 317   return ret;
 318 }
 319
 320 /* ------------------------------------------
 321    FIXME work only if < 2GB
 322 */
 323 static int ad_convert(struct adouble *ad, const char *path)
 324 {
 325   struct stat st;
 326   u_int16_t attr;
 327   char *buf;
 328   int fd, off;
 329   int ret = -1;
 330   /* use resource fork offset from file */
 331   int shiftdata;
 332   int toV2;
 333   int toV1;
 334
 335   if (!path) {
 336       return 0;
 337   }
 338
 339   if (!(ad->ad_hf.adf_flags & ( O_RDWR))) {
 340       /* we were unable to open the file read write the last time */
 341       return 0;
 342   }
 343
 344   /* check to see if we should convert this header. */
 345   toV2 = ad->ad_version == AD_VERSION1 && ad->ad_flags == AD_VERSION2;
 346   toV1 = ad->ad_version == AD_VERSION2 && ad->ad_flags == AD_VERSION1;
 347
 348   if (!toV2 && !toV1)
 349       return 0;
 350
 351   /* convert from v1 to v2. what does this mean?
 352    *  1) change FILEI into FILEDATESI
 353    *  2) create space for SHORTNAME, AFPFILEI, DID, and PRODOSI
 354    *  3) move FILEI attributes into AFPFILEI
 355    *  4) initialize ACCESS field of FILEDATESI.
 356    *  5) move the resource fork
 357    */
 358
 359   /* bail if we can't get a lock */
 360   if (ad_tmplock(ad, ADEID_RFORK, ADLOCK_WR, 0, 0, 0) < 0)
 361     goto bail_err;
 362
 363   /* we reuse fd from the resource fork */
 364   fd = ad->ad_hf.adf_fd;
 365
 366   if (ad->ad_eid[ADEID_RFORK].ade_off) {
 367       shiftdata = ADEDOFF_RFORK_V2 -ad->ad_eid[ADEID_RFORK].ade_off;
 368   }
 369   else {
 370       shiftdata = ADEDOFF_RFORK_V2 -ADEDOFF_RFORK_V1; /* 136 */
 371   }
 372
 373   if (fstat(fd, &st)) {
 374       goto bail_lock;
 375   }
 376
 377   if (st.st_size > 0x7fffffff -shiftdata) {
 378       LOG(log_debug, logtype_default, "ad_v1tov2: file too big.");
 379       errno = EIO;
 380       goto bail_lock;
 381   }
 382
 383   off = ad->ad_eid[ADEID_RFORK].ade_off;
 384
 385   if (off > st.st_size) {
 386       LOG(log_error, logtype_default, "ad_v1tov2: invalid resource fork offset. (off: %u)", off);
 387       errno = EIO;
 388       goto bail_lock;
 389   }
 390
 391   if (ad->ad_eid[ADEID_RFORK].ade_len > st.st_size - off) {
 392       LOG(log_error, logtype_default, "ad_v1tov2: invalid resource fork length. (rfork len: %u)", ad->ad_eid[ADEID_RFORK].ade_len);
 393       errno = EIO;
 394       goto bail_lock;
 395   }
 396
 397   if ((void *) (buf = (char *)
 398                 mmap(NULL, st.st_size + shiftdata,
 399                      PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) ==
 400           MAP_FAILED) {
 401     goto bail_lock;
 402   }
 403
 404   /* last place for failure. */
 405
 406   if (sys_ftruncate(fd, st.st_size + shiftdata) < 0) {
 407       goto bail_lock;
 408   }
 409
 410   /* move the RFORK. this assumes that the RFORK is at the end */
 411   if (off) {
 412       memmove(buf + ADEDOFF_RFORK_V2, buf + off, ad->ad_eid[ADEID_RFORK].ade_len);
 413   }
 414
 415   munmap(buf, st.st_size + shiftdata);
 416
 417   /* now, fix up our copy of the header */
 418   memset(ad->ad_filler, 0, sizeof(ad->ad_filler));
 419
 420   /* replace FILEI with FILEDATESI */
 421   ad_getattr(ad, &attr);
 422   ad->ad_eid[ADEID_FILEDATESI].ade_off = ADEDOFF_FILEDATESI;
 423   ad->ad_eid[ADEID_FILEDATESI].ade_len = ADEDLEN_FILEDATESI;
 424   ad->ad_eid[ADEID_FILEI].ade_off = 0;
 425   ad->ad_eid[ADEID_FILEI].ade_len = 0;
 426
 427   /* add in the new entries */
 428   ad->ad_eid[ADEID_DID].ade_off = ADEDOFF_DID;
 429   ad->ad_eid[ADEID_DID].ade_len = ADEDLEN_DID;
 430   ad->ad_eid[ADEID_AFPFILEI].ade_off = ADEDOFF_AFPFILEI;
 431   ad->ad_eid[ADEID_AFPFILEI].ade_len = ADEDLEN_AFPFILEI;
 432   ad->ad_eid[ADEID_SHORTNAME].ade_off = ADEDOFF_SHORTNAME;
 433   ad->ad_eid[ADEID_SHORTNAME].ade_len = ADEDLEN_INIT;
 434   ad->ad_eid[ADEID_PRODOSFILEI].ade_off = ADEDOFF_PRODOSFILEI;
 435   ad->ad_eid[ADEID_PRODOSFILEI].ade_len = ADEDLEN_PRODOSFILEI;
 436
 437   ad->ad_eid[ADEID_PRIVDEV].ade_off = ADEDOFF_PRIVDEV;
 438   ad->ad_eid[ADEID_PRIVDEV].ade_len = ADEDLEN_INIT;
 439   ad->ad_eid[ADEID_PRIVINO].ade_off = ADEDOFF_PRIVINO;
 440   ad->ad_eid[ADEID_PRIVINO].ade_len = ADEDLEN_INIT;
 441   ad->ad_eid[ADEID_PRIVSYN].ade_off = ADEDOFF_PRIVSYN;
 442   ad->ad_eid[ADEID_PRIVSYN].ade_len = ADEDLEN_INIT;
 443   ad->ad_eid[ADEID_PRIVID].ade_off  = ADEDOFF_PRIVID;
 444   ad->ad_eid[ADEID_PRIVID].ade_len =  ADEDLEN_INIT;
 445
 446   /* shift the old entries (NAME, COMMENT, FINDERI, RFORK) */
 447   ad->ad_eid[ADEID_NAME].ade_off = ADEDOFF_NAME_V2;
 448   ad->ad_eid[ADEID_COMMENT].ade_off = ADEDOFF_COMMENT_V2;
 449   ad->ad_eid[ADEID_FINDERI].ade_off = ADEDOFF_FINDERI_V2;
 450   ad->ad_eid[ADEID_RFORK].ade_off = ADEDOFF_RFORK_V2;
 451
 452   /* switch to dest version */
 453   ad->ad_version = (toV2)?AD_VERSION2:AD_VERSION1;
 454
 455   /* move our data buffer to make space for the new entries. */
 456   memmove(ad->ad_data + ADEDOFF_NAME_V2, ad->ad_data + ADEDOFF_NAME_V1,
 457           ADEDOFF_RFORK_V1 - ADEDOFF_NAME_V1);
 458
 459   /* now, fill in the space with appropriate stuff. we're
 460      operating as a v2 file now. */
 461   ad_setdate(ad, AD_DATE_ACCESS | AD_DATE_UNIX, st.st_mtime);
 462   memset(ad_entry(ad, ADEID_DID), 0, ADEDLEN_DID);
 463   memset(ad_entry(ad, ADEID_AFPFILEI), 0, ADEDLEN_AFPFILEI);
 464   ad_setattr(ad, attr);
 465   memset(ad_entry(ad, ADEID_SHORTNAME), 0, ADEDLEN_SHORTNAME);
 466   memset(ad_entry(ad, ADEID_PRODOSFILEI), 0, ADEDLEN_PRODOSFILEI);
 467
 468   /* rebuild the header and cleanup */
 469   ad_flush(ad, ADFLAGS_HF );
 470   ret = 0;
 471
 472 bail_lock:
 473   ad_tmplock(ad, ADEID_RFORK, ADLOCK_CLR, 0, 0, 0);
 474 bail_err:
 475   return ret;
 476 }
 477 #endif /* AD_VERSION == AD_VERSION2 */
 478
 479 /* --------------------------- */
 480 #ifdef ATACC
 481 mode_t ad_hf_mode (mode_t mode)
 482 {
 483     /* we always need RW mode for file owner */
 484 #if 0
 485     mode |= S_IRUSR;
 486 #endif
 487     mode &= ~(S_IXUSR | S_IXGRP | S_IXOTH);
 488     /* fnctl lock need write access */
 489     if ((mode & S_IRUSR))
 490         mode |= S_IWUSR;
 491     if ((mode & S_IRGRP))
 492         mode |= S_IWGRP;
 493     if ((mode & S_IROTH))
 494         mode |= S_IWOTH;
 495     /* if write mode set add read mode */
 496     if ((mode & S_IWUSR))
 497         mode |= S_IRUSR;
 498     if ((mode & S_IWGRP))
 499         mode |= S_IRGRP;
 500     if ((mode & S_IWOTH))
 501         mode |= S_IROTH;
 502
 503     return mode;
 504 }
 505
 506 #endif
 507
 508 /* -------------------------------------
 509   read in the entries
 510 */
 511 static void parse_entries(struct adouble *ad, char *buf,
 512                                     u_int16_t nentries)
 513 {
 514     u_int32_t   eid, len, off;
 515     int         warning = 0;
 516
 517     /* now, read in the entry bits */
 518     for (; nentries > 0; nentries-- ) {
 519         memcpy(&eid, buf, sizeof( eid ));
 520         eid = DISK_EID(ad, ntohl( eid ));
 521         buf += sizeof( eid );
 522         memcpy(&off, buf, sizeof( off ));
 523         off = ntohl( off );
 524         buf += sizeof( off );
 525         memcpy(&len, buf, sizeof( len ));
 526         len = ntohl( len );
 527         buf += sizeof( len );
 528
 529         if (eid && eid < ADEID_MAX && ( (off < sizeof(ad->ad_data) &&
 530                  off +len <= sizeof(ad->ad_data)) || eid == ADEID_RFORK)) {
 531             ad->ad_eid[ eid ].ade_off = off;
 532             ad->ad_eid[ eid ].ade_len = len;
 533         } else if (!warning) {
 534             warning = 1;
 535             LOG(log_debug, logtype_default, "ad_refresh: nentries %hd  eid %d",
 536                     nentries, eid );
 537         }
 538     }
 539 }
 540
 541
 542 /* this reads enough of the header so that we can figure out all of
 543  * the entry lengths and offsets. once that's done, we just read/mmap
 544  * the rest of the header in.
 545  *
 546  * NOTE: we're assuming that the resource fork is kept at the end of
 547  *       the file. also, mmapping won't work for the hfs fs until it
 548  *       understands how to mmap header files. */
 549 static int ad_header_read(struct adouble *ad, struct stat *hst)
 550 {
 551     char                *buf = ad->ad_data;
 552     u_int16_t           nentries;
 553     int                 len;
 554     ssize_t             header_len;
 555     static int          warning = 0;
 556     struct stat         st;
 557
 558     /* read the header */
 559     if ((header_len = adf_pread( &ad->ad_hf, buf, sizeof(ad->ad_data), 0)) < 0) {
 560         return -1;
 561     }
 562     if (header_len < AD_HEADER_LEN) {
 563         errno = EIO;
 564         return -1;
 565     }
 566
 567     memcpy(&ad->ad_magic, buf, sizeof( ad->ad_magic ));
 568     memcpy(&ad->ad_version, buf + ADEDOFF_VERSION, sizeof( ad->ad_version ));
 569
 570     /* tag broken v1 headers. just assume they're all right.
 571      * we detect two cases: null magic/version
 572      *                      byte swapped magic/version
 573      * XXX: in the future, you'll need the v1compat flag.
 574      * (ad->ad_flags & ADFLAGS_V1COMPAT) */
 575     if (!ad->ad_magic && !ad->ad_version) {
 576       if (!warning) {
 577         LOG(log_debug, logtype_default, "notice: fixing up null v1 magic/version.");
 578         warning++;
 579       }
 580       ad->ad_magic = AD_MAGIC;
 581       ad->ad_version = AD_VERSION1;
 582
 583     } else if (ad->ad_magic == AD_MAGIC && ad->ad_version == AD_VERSION1) {
 584       if (!warning) {
 585         LOG(log_debug, logtype_default, "notice: fixing up byte-swapped v1 magic/version.");
 586         warning++;
 587       }
 588
 589     } else {
 590       ad->ad_magic = ntohl( ad->ad_magic );
 591       ad->ad_version = ntohl( ad->ad_version );
 592     }
 593
 594     if ((ad->ad_magic != AD_MAGIC) || ((ad->ad_version != AD_VERSION1)
 595 #if AD_VERSION == AD_VERSION2
 596                                        && (ad->ad_version != AD_VERSION2)
 597 #endif /* AD_VERSION == AD_VERSION2 */
 598                                        )) {
 599       errno = EIO;
 600       LOG(log_debug, logtype_default, "ad_open: can't parse AppleDouble header.");
 601       return -1;
 602     }
 603
 604     memcpy(ad->ad_filler, buf + ADEDOFF_FILLER, sizeof( ad->ad_filler ));
 605     memcpy(&nentries, buf + ADEDOFF_NENTRIES, sizeof( nentries ));
 606     nentries = ntohs( nentries );
 607
 608     /* read in all the entry headers. if we have more than the
 609      * maximum, just hope that the rfork is specified early on. */
 610     len = nentries*AD_ENTRY_LEN;
 611
 612     if (len + AD_HEADER_LEN > sizeof(ad->ad_data))
 613       len = sizeof(ad->ad_data) - AD_HEADER_LEN;
 614
 615     buf += AD_HEADER_LEN;
 616     if (len > header_len - AD_HEADER_LEN) {
 617         errno = EIO;
 618         LOG(log_debug, logtype_default, "ad_header_read: can't read entry info.");
 619         return -1;
 620     }
 621
 622     /* figure out all of the entry offsets and lengths. if we aren't
 623      * able to read a resource fork entry, bail. */
 624     nentries = len / AD_ENTRY_LEN;
 625     parse_entries(ad, buf, nentries);
 626     if (!ad_getentryoff(ad, ADEID_RFORK)
 627         || (ad_getentryoff(ad, ADEID_RFORK) > sizeof(ad->ad_data))
 628         ) {
 629         errno = EIO;
 630         LOG(log_debug, logtype_default, "ad_header_read: problem with rfork entry offset.");
 631         return -1;
 632     }
 633
 634     if (ad_getentryoff(ad, ADEID_RFORK) > header_len) {
 635         errno = EIO;
 636         LOG(log_debug, logtype_default, "ad_header_read: can't read in entries.");
 637         return -1;
 638     }
 639
 640     if (hst == NULL) {
 641         hst = &st;
 642         if (fstat(ad->ad_hf.adf_fd, &st) < 0) {
 643             return 1; /* fail silently */
 644          }
 645     }
 646     ad->ad_rlen = hst->st_size - ad_getentryoff(ad, ADEID_RFORK);
 647
 648     /* fix up broken dates */
 649     if (ad->ad_version == AD_VERSION1) {
 650       u_int32_t aint;
 651
 652       /* check to see if the ad date is wrong. just see if we have
 653       * a modification date in the future. */
 654       if (((ad_getdate(ad, AD_DATE_MODIFY | AD_DATE_UNIX, &aint)) == 0) &&
 655           (aint > TIMEWARP_DELTA + hst->st_mtime)) {
 656         ad_setdate(ad, AD_DATE_MODIFY | AD_DATE_UNIX, aint - AD_DATE_DELTA);
 657         ad_getdate(ad, AD_DATE_CREATE | AD_DATE_UNIX, &aint);
 658         ad_setdate(ad, AD_DATE_CREATE | AD_DATE_UNIX, aint - AD_DATE_DELTA);
 659         ad_getdate(ad, AD_DATE_BACKUP | AD_DATE_UNIX, &aint);
 660         ad_setdate(ad, AD_DATE_BACKUP | AD_DATE_UNIX, aint - AD_DATE_DELTA);
 661       }
 662     }
 663
 664     return 0;
 665 }
 666
 667 /* ---------------------------------------
 668  * Put the .AppleDouble where it needs to be:
 669  *
 670  *          /   a/.AppleDouble/b
 671  *      a/b
 672  *          \   b/.AppleDouble/.Parent
 673  *
 674  * FIXME: should do something for pathname > MAXPATHLEN
 675  */
 676 char *
 677 ad_path( path, adflags )
 678     const char  *path;
 679     int         adflags;
 680 {
 681     static char pathbuf[ MAXPATHLEN + 1];
 682     char        c, *slash, buf[MAXPATHLEN + 1];
 683     size_t      l;
 684
 685     l = strlcpy(buf, path, MAXPATHLEN +1);
 686     if ( adflags & ADFLAGS_DIR ) {
 687         strcpy( pathbuf, buf);
 688         if ( *buf != '\0' && l < MAXPATHLEN) {
 689             pathbuf[l++] = '/';
 690             pathbuf[l] = 0;
 691         }
 692         slash = ".Parent";
 693     } else {
 694         if (NULL != ( slash = strrchr( buf, '/' )) ) {
 695             c = *++slash;
 696             *slash = '\0';
 697             strcpy( pathbuf, buf);
 698             *slash = c;
 699         } else {
 700             pathbuf[ 0 ] = '\0';
 701             slash = buf;
 702         }
 703     }
 704     strlcat( pathbuf, ".AppleDouble/", MAXPATHLEN +1);
 705     strlcat( pathbuf, slash, MAXPATHLEN +1);
 706
 707     return( pathbuf );
 708 }
 709
 710 /* ---------------------------------------
 711  * Put the resource fork where it needs to be:
 712  * ._name
 713  */
 714 char *
 715 ad_path_osx( const char *path, int adflags _U_)
 716 {
 717     static char pathbuf[ MAXPATHLEN + 1];
 718     char        c, *slash, buf[MAXPATHLEN + 1];
 719
 720     if (!strcmp(path,".")) {
 721             /* fixme */
 722         getcwd(buf, MAXPATHLEN);
 723     }
 724     else {
 725         strlcpy(buf, path, MAXPATHLEN +1);
 726     }
 727     if (NULL != ( slash = strrchr( buf, '/' )) ) {
 728         c = *++slash;
 729         *slash = '\0';
 730         strlcpy( pathbuf, buf, MAXPATHLEN +1);
 731         *slash = c;
 732     } else {
 733         pathbuf[ 0 ] = '\0';
 734         slash = buf;
 735     }
 736     strlcat( pathbuf, "._", MAXPATHLEN  +1);
 737     strlcat( pathbuf, slash, MAXPATHLEN +1);
 738     return pathbuf;
 739 }
 740
 741 /*
 742  * Support inherited protection modes for AppleDouble files.  The supplied
 743  * mode is ANDed with the parent directory's mask value in lieu of "umask",
 744  * and that value is returned.
 745  */
 746
 747 #define DEFMASK 07700   /* be conservative */
 748
 749 char
 750 *ad_dir(path)
 751     const char          *path;
 752 {
 753     static char         modebuf[ MAXPATHLEN + 1];
 754     char                *slash;
 755     size_t              len;
 756
 757     if ( (len = strlen( path )) >= MAXPATHLEN ) {
 758         errno = ENAMETOOLONG;
 759         return NULL;  /* can't do it */
 760     }
 761
 762     /*
 763      * For a path with directories in it, remove the final component
 764      * (path or subdirectory name) to get the name we want to stat.
 765      * For a path which is just a filename, use "." instead.
 766      */
 767     strcpy( modebuf, path );
 768     slash = strrchr( modebuf, '/' );
 769     /* is last char a '/' */
 770     if (slash && slash[1] == 0) {
 771         while (modebuf < slash && slash[-1] == '/') {
 772             --slash;
 773         }
 774         if (modebuf < slash) {
 775             *slash = '\0';              /* remove pathname component */
 776             slash = strrchr( modebuf, '/' );
 777         }
 778     }
 779     if (slash) {
 780         *slash = '\0';          /* remove pathname component */
 781     } else {
 782         modebuf[0] = '.';       /* use current directory */
 783         modebuf[1] = '\0';
 784     }
 785     return modebuf;
 786 }
 787
 788 /* ---------------- */
 789 static uid_t default_uid = -1;
 790
 791 int ad_setfuid(const uid_t id)
 792 {
 793     default_uid = id;
 794     return 0;
 795 }
 796
 797 /* ---------------- */
 798 uid_t ad_getfuid(void)
 799 {
 800     return default_uid;
 801 }
 802
 803 /* ----------------
 804    return inode of path parent directory
 805 */
 806 int ad_stat(const char *path, struct stat *stbuf)
 807 {
 808     char                *p;
 809
 810     p = ad_dir(path);
 811     if (!p) {
 812         return -1;
 813     }
 814
 815     return stat( p, stbuf );
 816 }
 817
 818 /* ----------------
 819    if we are root change path user/ group
 820    It can be a native function for BSD cf. FAQ.Q10
 821    path:  pathname to chown
 822    stbuf: parent directory inode
 823
 824    use fstat and fchown or lchown with linux?
 825 */
 826 #define EMULATE_SUIDDIR
 827
 828 static int ad_chown(const char *path, struct stat *stbuf)
 829 {
 830 int ret = 0;
 831 #ifdef EMULATE_SUIDDIR
 832 uid_t id;
 833
 834     if (default_uid != (uid_t)-1) {
 835         /* we are root (admin) */
 836         id = (default_uid)?default_uid:stbuf->st_uid;
 837         ret = chown( path, id, stbuf->st_gid );
 838     }
 839 #endif
 840     return ret;
 841 }
 842
 843 /* ----------------
 844    return access right and inode of path parent directory
 845 */
 846 static int ad_mode_st(const char *path, int *mode, struct stat *stbuf)
 847 {
 848     if (*mode == 0) {
 849        return -1;
 850     }
 851     if (ad_stat(path, stbuf) != 0) {
 852         *mode &= DEFMASK;
 853         return -1;
 854     }
 855     *mode &= stbuf->st_mode;
 856     return 0;
 857 }
 858
 859 /* ----------------
 860    return access right of path parent directory
 861 */
 862 int
 863 ad_mode( path, mode )
 864     const char          *path;
 865     int                 mode;
 866 {
 867     struct stat         stbuf;
 868     ad_mode_st(path, &mode, &stbuf);
 869     return mode;
 870 }
 871
 872 /*
 873  * Use mkdir() with mode bits taken from ad_mode().
 874  */
 875 int
 876 ad_mkdir( path, mode )
 877     const char          *path;
 878     int                 mode;
 879 {
 880 int ret;
 881 int st_invalid;
 882 struct stat stbuf;
 883
 884 #ifdef DEBUG
 885     LOG(log_info, logtype_default, "ad_mkdir: Creating directory with mode %d", mode);
 886 #endif /* DEBUG */
 887
 888     st_invalid = ad_mode_st(path, &mode, &stbuf);
 889     ret = mkdir( path, mode );
 890     if (ret || st_invalid)
 891         return ret;
 892     ad_chown(path, &stbuf);
 893
 894     return ret;
 895 }
 896
 897 /* ----------------- */
 898 static int ad_error(struct adouble *ad, int adflags)
 899 {
 900 int err = errno;
 901     if ((adflags & ADFLAGS_NOHF)) {
 902         /* FIXME double check : set header offset ?*/
 903         return 0;
 904     }
 905     if ((adflags & ADFLAGS_DF)) {
 906         ad_close( ad, ADFLAGS_DF );
 907         err = errno;
 908     }
 909     return -1 ;
 910 }
 911
 912 static int new_rfork(const char *path, struct adouble *ad, int adflags);
 913
 914 #ifdef  HAVE_PREAD
 915 #define AD_SET(a)
 916 #else
 917 #define AD_SET(a) a = 0
 918 #endif
 919
 920 void ad_init(struct adouble *ad, int flags, int options)
 921 {
 922     memset( ad, 0, sizeof( struct adouble ) );
 923     ad->ad_flags = flags;
 924     if (flags == AD_VERSION2_OSX) {
 925         ad->ad_path     = ad_path_osx;
 926     }
 927     else {
 928         ad->ad_path     = ad_path;
 929     }
 930     ad->ad_options = options;
 931 }
 932
 933 /* -------------------
 934  * It's not possible to open the header file O_RDONLY -- the read
 935  * will fail and return an error. this refcounts things now.
 936  */
 937 int ad_open( path, adflags, oflags, mode, ad )
 938     const char          *path;
 939     int                 adflags, oflags, mode;
 940     struct adouble      *ad;
 941 {
 942     struct stat         st;
 943     char                *slash, *ad_p;
 944     int                 hoflags, admode;
 945     int                 st_invalid = -1;
 946     int                 open_df = 0;
 947
 948     if (ad->ad_inited != AD_INITED) {
 949         ad_dfileno(ad) = -1;
 950         ad_hfileno(ad) = -1;
 951         adf_lock_init(&ad->ad_df);
 952         adf_lock_init(&ad->ad_hf);
 953         ad->ad_inited = AD_INITED;
 954         ad->ad_refcount = 1;
 955     }
 956
 957     if ((adflags & ADFLAGS_DF)) {
 958         if (ad_dfileno(ad) == -1) {
 959           hoflags = (oflags & ~(O_RDONLY | O_WRONLY)) | O_RDWR;
 960           admode = mode;
 961           if ((oflags & O_CREAT)) {
 962               st_invalid = ad_mode_st(path, &admode, &st);
 963               if ((ad->ad_options & ADVOL_UNIXPRIV)) {
 964                   admode = mode;
 965               }
 966           }
 967           ad->ad_df.adf_fd =open( path, hoflags, admode );
 968           if (ad->ad_df.adf_fd < 0 ) {
 969              if ((errno == EACCES || errno == EROFS) && !(oflags & O_RDWR)) {
 970                 hoflags = oflags;
 971                 ad->ad_df.adf_fd = open( path, hoflags, admode );
 972              }
 973           }
 974           if ( ad->ad_df.adf_fd < 0)
 975                 return -1;
 976
 977           AD_SET(ad->ad_df.adf_off);
 978           ad->ad_df.adf_flags = hoflags;
 979           if (!st_invalid) {
 980               /* just created, set owner if admin (root) */
 981               ad_chown(path, &st);
 982           }
 983         }
 984         else {
 985             /* the file is already open... but */
 986             if ((oflags & ( O_RDWR | O_WRONLY)) &&             /* we want write access */
 987                 !(ad->ad_df.adf_flags & ( O_RDWR | O_WRONLY))) /* and it was denied the first time */
 988             {
 989                  errno = EACCES;
 990                  return -1;
 991             }
 992             /* FIXME
 993              * for now ad_open is never called with O_TRUNC or O_EXCL if the file is
 994              * already open. Should we check for it? ie
 995              * O_EXCL --> error
 996              * O_TRUNC --> truncate the fork.
 997              * idem for ressource fork.
 998              */
 999         }
1000         open_df = ADFLAGS_DF;
1001         ad->ad_df.adf_refcount++;
1002     }
1003
1004     if (!(adflags & ADFLAGS_HF))
1005         return 0;
1006
1007     if (ad_hfileno(ad) != -1) { /* the file is already open */
1008         if ((oflags & ( O_RDWR | O_WRONLY)) &&
1009                 !(ad->ad_hf.adf_flags & ( O_RDWR | O_WRONLY))) {
1010             if (open_df) {
1011                 /* don't call with ADFLAGS_HF because we didn't open ressource fork */
1012                 ad_close( ad, open_df );
1013             }
1014             errno = EACCES;
1015             return -1;
1016         }
1017         ad_refresh(ad);
1018         ad->ad_hf.adf_refcount++;
1019         return 0;
1020     }
1021
1022     ad_p = ad->ad_path( path, adflags );
1023
1024     hoflags = oflags & ~O_CREAT;
1025     if (!(adflags & ADFLAGS_RDONLY)) {
1026         hoflags = (hoflags & ~(O_RDONLY | O_WRONLY)) | O_RDWR;
1027     }
1028     ad->ad_hf.adf_fd = open( ad_p, hoflags, 0 );
1029     if (ad->ad_hf.adf_fd < 0 ) {
1030         if ((errno == EACCES || errno == EROFS) && !(oflags & O_RDWR)) {
1031             hoflags = oflags & ~O_CREAT;
1032             ad->ad_hf.adf_fd = open( ad_p, hoflags, 0 );
1033         }
1034     }
1035
1036     if ( ad->ad_hf.adf_fd < 0 ) {
1037         if (errno == ENOENT && (oflags & O_CREAT) ) {
1038             /*
1039              * We're expecting to create a new adouble header file,
1040              * here.
1041              * if ((oflags & O_CREAT) ==> (oflags & O_RDWR)
1042              */
1043             admode = mode;
1044             errno = 0;
1045             st_invalid = ad_mode_st(ad_p, &admode, &st);
1046             if ((ad->ad_options & ADVOL_UNIXPRIV)) {
1047                 admode = mode;
1048             }
1049             admode = ad_hf_mode(admode);
1050             if ( errno == ENOENT && !(adflags & ADFLAGS_NOADOUBLE) && ad->ad_flags != AD_VERSION2_OSX) {
1051                 /*
1052                  * Probably .AppleDouble doesn't exist, try to
1053                  * mkdir it.
1054                  */
1055                 if (NULL == ( slash = strrchr( ad_p, '/' )) ) {
1056                     return ad_error(ad, adflags);
1057                 }
1058                 *slash = '\0';
1059                 errno = 0;
1060                 if ( ad_mkdir( ad_p, 0777 ) < 0 ) {
1061                     return ad_error(ad, adflags);
1062                 }
1063                 *slash = '/';
1064                 admode = mode;
1065                 st_invalid = ad_mode_st(ad_p, &admode, &st);
1066                 if ((ad->ad_options & ADVOL_UNIXPRIV)) {
1067                     admode = mode;
1068                 }
1069                 admode = ad_hf_mode(admode);
1070             }
1071             /* retry with O_CREAT */
1072             ad->ad_hf.adf_fd = open( ad_p, oflags,admode );
1073             if ( ad->ad_hf.adf_fd < 0 ) {
1074                 return ad_error(ad, adflags);
1075             }
1076             ad->ad_hf.adf_flags = oflags;
1077             /* just created, set owner if admin owner (root) */
1078             if (!st_invalid) {
1079                 ad_chown(ad_p, &st);
1080             }
1081         }
1082         else {
1083             return ad_error(ad, adflags);
1084         }
1085     } else if (fstat(ad->ad_hf.adf_fd, &st) == 0 && st.st_size == 0) {
1086         /* for 0 length files, treat them as new. */
1087         ad->ad_hf.adf_flags = hoflags| O_TRUNC;
1088     } else {
1089         ad->ad_hf.adf_flags = hoflags;
1090     }
1091     AD_SET(ad->ad_hf.adf_off);
1092
1093     memset(ad->ad_eid, 0, sizeof( ad->ad_eid ));
1094     ad->ad_hf.adf_refcount++;
1095     if ((ad->ad_hf.adf_flags & ( O_TRUNC | O_CREAT ))) {
1096         /*
1097          * This is a new adouble header file. Initialize the structure,
1098          * instead of reading it.
1099         */
1100         if (new_rfork(path, ad, adflags) < 0) {
1101             int err = errno;
1102             /* the file is already deleted, perm, whatever, so return an error*/
1103             ad_close(ad, adflags);
1104             errno = err;
1105             return -1;
1106         }
1107     } else {
1108             /* Read the adouble header in and parse it.*/
1109         if ((ad_header_read( ad , &st) < 0)
1110 #if AD_VERSION == AD_VERSION2
1111                 || (ad_convert(ad, ad_p) < 0) || (ad_update(ad, ad_p) < 0)
1112 #endif /* AD_VERSION == AD_VERSION2 */
1113         ) {
1114             int err = errno;
1115
1116             ad_close( ad, adflags );
1117             errno = err;
1118             return -1;
1119         }
1120     }
1121     return 0 ;
1122 }
1123
1124 /* -----------------------------------
1125  * return only metadata but try very hard
1126 */
1127 int ad_metadata(const char *name, int flags, struct adouble *adp)
1128 {
1129     uid_t uid;
1130     int   ret, err;
1131
1132     if ((ret = ad_open(name, ADFLAGS_HF | (flags), O_RDONLY, 0, adp)) < 0 && errno == EACCES) {
1133         uid = geteuid();
1134         if (seteuid(0)) {
1135             LOG(log_error, logtype_default, "ad_metadata(%s): seteuid failed %s", name, strerror(errno));
1136             errno = EACCES;
1137             return -1;
1138         }
1139         /* we are root open read only */
1140         ret = ad_open(name, ADFLAGS_HF|ADFLAGS_RDONLY|(flags), O_RDONLY, 0, adp);
1141         err = errno;
1142         if ( seteuid(uid) < 0) {
1143             LOG(log_error, logtype_default, "ad_metadata: can't seteuid back");
1144             exit(EXITERR_SYS);
1145         }
1146         errno = err;
1147     }
1148     return ret;
1149 }
1150
1151 /* ----------------------------------- */
1152 static int new_rfork(const char *path, struct adouble *ad, int adflags)
1153 {
1154     const struct entry  *eid;
1155     u_int16_t           ashort;
1156     struct stat         st;
1157
1158     ad->ad_magic = AD_MAGIC;
1159     ad->ad_version = ad->ad_flags & 0x0f0000;
1160     if (!ad->ad_version) {
1161         ad->ad_version = AD_VERSION;
1162     }
1163
1164     memset(ad->ad_filler, 0, sizeof( ad->ad_filler ));
1165     memset(ad->ad_data, 0, sizeof(ad->ad_data));
1166
1167 #if AD_VERSION == AD_VERSION2
1168     if (ad->ad_flags == AD_VERSION2)
1169        eid = entry_order2;
1170     else if (ad->ad_flags == AD_VERSION2_OSX)
1171        eid = entry_order_osx;
1172     else
1173 #endif
1174        eid = entry_order1;
1175
1176     while (eid->id) {
1177         ad->ad_eid[eid->id].ade_off = eid->offset;
1178         ad->ad_eid[eid->id].ade_len = eid->len;
1179         eid++;
1180     }
1181
1182     /* put something sane in the directory finderinfo */
1183     if ((adflags & ADFLAGS_DIR)) {
1184         /* set default view */
1185         ashort = htons(FINDERINFO_CLOSEDVIEW);
1186         memcpy(ad_entry(ad, ADEID_FINDERI) + FINDERINFO_FRVIEWOFF,
1187                      &ashort, sizeof(ashort));
1188     } else {
1189         /* set default creator/type fields */
1190         memcpy(ad_entry(ad, ADEID_FINDERI) + FINDERINFO_FRTYPEOFF,"\0\0\0\0", 4);
1191         memcpy(ad_entry(ad, ADEID_FINDERI) + FINDERINFO_FRCREATOFF,"\0\0\0\0", 4);
1192     }
1193
1194     /* make things invisible */
1195     if ((ad->ad_options & ADVOL_INVDOTS) && !(adflags & ADFLAGS_CREATE) &&
1196            (*path == '.') && strcmp(path, ".") && strcmp(path, ".."))
1197     {
1198         ashort = htons(ATTRBIT_INVISIBLE);
1199         ad_setattr(ad, ashort);
1200         ashort = htons(FINDERINFO_INVISIBLE);
1201         memcpy(ad_entry(ad, ADEID_FINDERI) + FINDERINFO_FRFLAGOFF, &ashort, sizeof(ashort));
1202     }
1203
1204     if (stat(path, &st) < 0) {
1205         return -1;
1206     }
1207
1208     /* put something sane in the date fields */
1209     ad_setdate(ad, AD_DATE_CREATE | AD_DATE_UNIX, st.st_mtime);
1210     ad_setdate(ad, AD_DATE_MODIFY | AD_DATE_UNIX, st.st_mtime);
1211     ad_setdate(ad, AD_DATE_ACCESS | AD_DATE_UNIX, st.st_mtime);
1212     ad_setdate(ad, AD_DATE_BACKUP, AD_DATE_START);
1213     return 0;
1214 }
1215
1216 /* to do this with mmap, we need the hfs fs to understand how to mmap
1217    header files. */
1218 int ad_refresh(struct adouble *ad)
1219 {
1220
1221   if (ad->ad_hf.adf_fd < 0)
1222     return -1;
1223
1224   return ad_header_read(ad, NULL);
1225 }