etc/afpd/ofork.c

   1 /*
   2  * $Id: ofork.c,v 1.32 2010-03-12 15:16:49 franklahm Exp $
   3  *
   4  * Copyright (c) 1996 Regents of The University of Michigan.
   5  * All Rights Reserved.  See COPYRIGHT.
   6  */
   7
   8 #ifdef HAVE_CONFIG_H
   9 #include "config.h"
  10 #endif /* HAVE_CONFIG_H */
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #ifdef HAVE_UNISTD_H
  15 #include <unistd.h>
  16 #endif
  17 #include <string.h>
  18 #include <sys/stat.h> /* works around a bug */
  19 #include <sys/param.h>
  20 #include <atalk/logger.h>
  21 #include <errno.h>
  22
  23 #include <atalk/util.h>
  24
  25 #include "globals.h"
  26 #include "volume.h"
  27 #include "directory.h"
  28 #include "fork.h"
  29 #include "fce_api.h"
  30
  31 /* we need to have a hashed list of oforks (by dev inode). just hash
  32  * by first letter. */
  33 #define OFORK_HASHSIZE  64
  34 static struct ofork     *ofork_table[OFORK_HASHSIZE];
  35
  36 static struct ofork     **oforks = NULL;
  37 static int              nforks = 0;
  38 static u_short          lastrefnum = 0;
  39
  40
  41 /* OR some of each character for the hash*/
  42 static unsigned long hashfn(const struct file_key *key)
  43 {
  44 #if 0
  45     unsigned long i = 0;
  46     while (*name) {
  47         i = ((i << 4) | (8*sizeof(i) - 4)) ^ *name++;
  48     }
  49 #endif
  50     return key->inode & (OFORK_HASHSIZE - 1);
  51 }
  52
  53 static void of_hash(struct ofork *of)
  54 {
  55     struct ofork **table;
  56
  57     table = &ofork_table[hashfn(&of->key)];
  58     if ((of->next = *table) != NULL)
  59         (*table)->prevp = &of->next;
  60     *table = of;
  61     of->prevp = table;
  62 }
  63
  64 static void of_unhash(struct ofork *of)
  65 {
  66     if (of->prevp) {
  67         if (of->next)
  68             of->next->prevp = of->prevp;
  69         *(of->prevp) = of->next;
  70     }
  71 }
  72
  73 #ifdef DEBUG1
  74 void of_pforkdesc( FILE *f)
  75 {
  76     int ofrefnum;
  77
  78     if (!oforks)
  79         return;
  80
  81     for ( ofrefnum = 0; ofrefnum < nforks; ofrefnum++ ) {
  82         if ( oforks[ ofrefnum ] != NULL ) {
  83             fprintf( f, "%hu <%s>\n", ofrefnum, of_name(oforks[ ofrefnum ]));
  84         }
  85     }
  86 }
  87 #endif
  88
  89 int of_flush(const struct vol *vol)
  90 {
  91     int refnum;
  92
  93     if (!oforks)
  94         return 0;
  95
  96     for ( refnum = 0; refnum < nforks; refnum++ ) {
  97         if (oforks[ refnum ] != NULL && (oforks[refnum]->of_vol == vol) &&
  98                 flushfork( oforks[ refnum ] ) < 0 ) {
  99             LOG(log_error, logtype_afpd, "of_flush: %s", strerror(errno) );
 100         }
 101     }
 102     return( 0 );
 103 }
 104
 105 int of_rename(const struct vol *vol,
 106               struct ofork *s_of,
 107               struct dir *olddir, const char *oldpath _U_,
 108               struct dir *newdir, const char *newpath)
 109 {
 110     struct ofork *of, *next, *d_ofork;
 111     int done = 0;
 112
 113     if (!s_of)
 114         return AFP_OK;
 115
 116     next = ofork_table[hashfn(&s_of->key)];
 117     while ((of = next)) {
 118         next = next->next; /* so we can unhash and still be all right. */
 119
 120         if (vol == of->of_vol && olddir == of->of_dir &&
 121                  s_of->key.dev == of->key.dev &&
 122                  s_of->key.inode == of->key.inode ) {
 123             if (!done) {
 124                 strlcpy( of_name(of), newpath, of->of_ad->ad_m_namelen);
 125                 done = 1;
 126             }
 127             if (newdir != olddir) {
 128                 of->of_d_prev->of_d_next = of->of_d_next;
 129                 of->of_d_next->of_d_prev = of->of_d_prev;
 130                 if (of->of_dir->d_ofork == of) {
 131                     of->of_dir->d_ofork = (of == of->of_d_next) ? NULL : of->of_d_next;
 132                 }
 133                 of->of_dir = newdir;
 134                 if (!(d_ofork = newdir->d_ofork)) {
 135                     newdir->d_ofork = of;
 136                     of->of_d_next = of->of_d_prev = of;
 137                 } else {
 138                     of->of_d_next = d_ofork;
 139                     of->of_d_prev = d_ofork->of_d_prev;
 140                     of->of_d_prev->of_d_next = of;
 141                     d_ofork->of_d_prev = of;
 142                 }
 143             }
 144         }
 145     }
 146
 147     return AFP_OK;
 148 }
 149
 150 #define min(a,b)        ((a)<(b)?(a):(b))
 151
 152 struct ofork *
 153 of_alloc(struct vol *vol,
 154     struct dir     *dir,
 155     char           *path,
 156     u_int16_t      *ofrefnum,
 157     const int      eid,
 158     struct adouble *ad,
 159     struct stat    *st)
 160 {
 161     struct ofork        *of, *d_ofork;
 162     u_int16_t           refnum, of_refnum;
 163
 164     int                 i;
 165
 166     if (!oforks) {
 167         nforks = getdtablesize() - 10;
 168         /* protect against insane ulimit -n */
 169         nforks = min(nforks, 0xffff);
 170         oforks = (struct ofork **) calloc(nforks, sizeof(struct ofork *));
 171         if (!oforks)
 172             return NULL;
 173     }
 174
 175     for ( refnum = ++lastrefnum, i = 0; i < nforks; i++, refnum++ ) {
 176         /* cf AFP3.0.pdf, File fork page 40 */
 177         if (!refnum)
 178             refnum++;
 179         if ( oforks[ refnum % nforks ] == NULL ) {
 180             break;
 181         }
 182     }
 183     /* grr, Apple and their 'uniquely identifies'
 184           the next line is a protection against
 185           of_alloc()
 186              refnum % nforks = 3
 187              lastrefnum = 3
 188              oforks[3] != NULL
 189              refnum = 4
 190              oforks[4] == NULL
 191              return 4
 192
 193           close(oforks[4])
 194
 195           of_alloc()
 196              refnum % nforks = 4
 197              ...
 198              return 4
 199          same if lastrefnum++ rather than ++lastrefnum.
 200     */
 201     lastrefnum = refnum;
 202     if ( i == nforks ) {
 203         LOG(log_error, logtype_afpd, "of_alloc: maximum number of forks exceeded.");
 204         return( NULL );
 205     }
 206
 207     of_refnum = refnum % nforks;
 208     if (( oforks[ of_refnum ] =
 209                 (struct ofork *)malloc( sizeof( struct ofork ))) == NULL ) {
 210         LOG(log_error, logtype_afpd, "of_alloc: malloc: %s", strerror(errno) );
 211         return NULL;
 212     }
 213     of = oforks[of_refnum];
 214
 215     /* see if we need to allocate space for the adouble struct */
 216     if (!ad) {
 217         ad = malloc( sizeof( struct adouble ) );
 218         if (!ad) {
 219             LOG(log_error, logtype_afpd, "of_alloc: malloc: %s", strerror(errno) );
 220             free(of);
 221             oforks[ of_refnum ] = NULL;
 222             return NULL;
 223         }
 224
 225         /* initialize to zero. This is important to ensure that
 226            ad_open really does reinitialize the structure. */
 227         ad_init(ad, vol->v_adouble, vol->v_ad_options);
 228
 229         ad->ad_m_namelen = 255 +1;
 230         /* here's the deal: we allocate enough for the standard mac file length.
 231          * in the future, we'll reallocate in fairly large jumps in case
 232          * of long unicode names */
 233         if (( ad->ad_m_name =(char *)malloc( ad->ad_m_namelen )) == NULL ) {
 234             LOG(log_error, logtype_afpd, "of_alloc: malloc: %s", strerror(errno) );
 235             free(ad);
 236             free(of);
 237             oforks[ of_refnum ] = NULL;
 238             return NULL;
 239         }
 240         strlcpy( ad->ad_m_name, path, ad->ad_m_namelen);
 241     } else {
 242         /* Increase the refcount on this struct adouble. This is
 243            decremented again in oforc_dealloc. */
 244         ad->ad_refcount++;
 245     }
 246
 247     of->of_ad = ad;
 248     of->of_vol = vol;
 249     of->of_dir = dir;
 250
 251     if (!(d_ofork = dir->d_ofork)) {
 252         dir->d_ofork = of;
 253         of->of_d_next = of->of_d_prev = of;
 254     } else {
 255         of->of_d_next = d_ofork;
 256         of->of_d_prev = d_ofork->of_d_prev;
 257         d_ofork->of_d_prev->of_d_next = of;
 258         d_ofork->of_d_prev = of;
 259     }
 260
 261     *ofrefnum = refnum;
 262     of->of_refnum = refnum;
 263     of->key.dev = st->st_dev;
 264     of->key.inode = st->st_ino;
 265     if (eid == ADEID_DFORK)
 266         of->of_flags = AFPFORK_DATA;
 267     else
 268         of->of_flags = AFPFORK_RSRC;
 269
 270     of_hash(of);
 271     return( of );
 272 }
 273
 274 struct ofork *of_find(const u_int16_t ofrefnum )
 275 {
 276     if (!oforks || !nforks)
 277         return NULL;
 278
 279     return( oforks[ ofrefnum % nforks ] );
 280 }
 281
 282 /* -------------------------- */
 283 int of_stat  (struct path *path)
 284 {
 285 int ret;
 286     path->st_errno = 0;
 287     path->st_valid = 1;
 288     if ((ret = lstat(path->u_name, &path->st)) < 0)
 289         path->st_errno = errno;
 290    return ret;
 291 }
 292
 293 #ifdef HAVE_RENAMEAT
 294 int of_fstatat(int dirfd, struct path *path)
 295 {
 296     int ret;
 297
 298     path->st_errno = 0;
 299     path->st_valid = 1;
 300
 301     if ((ret = fstatat(dirfd, path->u_name, &path->st, AT_SYMLINK_NOFOLLOW)) < 0)
 302         path->st_errno = errno;
 303
 304    return ret;
 305 }
 306 #endif /* HAVE_RENAMEAT */
 307
 308 /* --------------------------
 309    stat the current directory.
 310    stat(".") works even if "." is deleted thus
 311    we have to stat ../name because we want to know if it's there
 312 */
 313 int of_statdir  (struct vol *vol, struct path *path)
 314 {
 315 static char pathname[ MAXPATHLEN + 1] = "../";
 316 int ret;
 317
 318     if (*path->m_name) {
 319         /* not curdir */
 320         return of_stat (path);
 321     }
 322     path->st_errno = 0;
 323     path->st_valid = 1;
 324     /* FIXME, what about: we don't have r-x perm anymore ? */
 325     strlcpy(pathname +3, path->d_dir->d_u_name, sizeof (pathname) -3);
 326
 327     if (!(ret = lstat(pathname, &path->st)))
 328         return 0;
 329
 330     path->st_errno = errno;
 331     /* hmm, can't stat curdir anymore */
 332     if (errno == EACCES && curdir->d_parent ) {
 333        if (movecwd(vol, curdir->d_parent))
 334            return -1;
 335        path->st_errno = 0;
 336        if ((ret = lstat(path->d_dir->d_u_name, &path->st)) < 0)
 337            path->st_errno = errno;
 338     }
 339     return ret;
 340 }
 341
 342 /* -------------------------- */
 343 struct ofork *of_findname(struct path *path)
 344 {
 345     struct ofork *of;
 346     struct file_key key;
 347
 348     if (!path->st_valid) {
 349        of_stat(path);
 350     }
 351
 352     if (path->st_errno)
 353         return NULL;
 354
 355     key.dev = path->st.st_dev;
 356     key.inode = path->st.st_ino;
 357
 358     for (of = ofork_table[hashfn(&key)]; of; of = of->next) {
 359         if (key.dev == of->key.dev && key.inode == of->key.inode ) {
 360             return of;
 361         }
 362     }
 363
 364     return NULL;
 365 }
 366
 367 /*!
 368  * @brief Search for open fork by dirfd/name
 369  *
 370  * Function call of_fstatat with dirfd and path and uses dev and ino
 371  * to search the open fork table.
 372  *
 373  * @param dirfd     (r) directory fd
 374  * @param path      (rw) pointer to struct path
 375  */
 376 #ifdef HAVE_RENAMEAT
 377 struct ofork *of_findnameat(int dirfd, struct path *path)
 378 {
 379     struct ofork *of;
 380     struct file_key key;
 381
 382     if ( ! path->st_valid) {
 383         of_fstatat(dirfd, path);
 384     }
 385
 386     if (path->st_errno)
 387         return NULL;
 388
 389     key.dev = path->st.st_dev;
 390     key.inode = path->st.st_ino;
 391
 392     for (of = ofork_table[hashfn(&key)]; of; of = of->next) {
 393         if (key.dev == of->key.dev && key.inode == of->key.inode ) {
 394             return of;
 395         }
 396     }
 397
 398     return NULL;
 399 }
 400 #endif
 401
 402 void of_dealloc( struct ofork *of)
 403 {
 404     if (!oforks)
 405         return;
 406
 407     of_unhash(of);
 408
 409     /* detach ofork */
 410     of->of_d_prev->of_d_next = of->of_d_next;
 411     of->of_d_next->of_d_prev = of->of_d_prev;
 412     if (of->of_dir->d_ofork == of) {
 413         of->of_dir->d_ofork = (of == of->of_d_next) ? NULL : of->of_d_next;
 414     }
 415
 416     oforks[ of->of_refnum % nforks ] = NULL;
 417
 418     /* decrease refcount */
 419     of->of_ad->ad_refcount--;
 420
 421     if ( of->of_ad->ad_refcount <= 0) {
 422         free( of->of_ad->ad_m_name );
 423         free( of->of_ad);
 424     } else {/* someone's still using it. just free this user's locks */
 425         ad_unlock(of->of_ad, of->of_refnum);
 426     }
 427
 428     free( of );
 429 }
 430
 431 /* --------------------------- */
 432 int of_closefork(struct ofork *ofork)
 433 {
 434     struct timeval      tv;
 435     int                 adflags, doflush = 0;
 436     int                 ret;
 437
 438     adflags = 0;
 439     if ((ofork->of_flags & AFPFORK_DATA) && (ad_data_fileno( ofork->of_ad ) != -1)) {
 440             adflags |= ADFLAGS_DF;
 441     }
 442     if ( (ofork->of_flags & AFPFORK_OPEN) && ad_reso_fileno( ofork->of_ad ) != -1 ) {
 443         adflags |= ADFLAGS_HF;
 444         /*
 445          * Only set the rfork's length if we're closing the rfork.
 446          */
 447         if ((ofork->of_flags & AFPFORK_RSRC)) {
 448             ad_refresh( ofork->of_ad );
 449             if ((ofork->of_flags & AFPFORK_DIRTY) && !gettimeofday(&tv, NULL)) {
 450                 ad_setdate(ofork->of_ad, AD_DATE_MODIFY | AD_DATE_UNIX,tv.tv_sec);
 451                 doflush++;
 452             }
 453             if ( doflush ) {
 454                  ad_flush( ofork->of_ad );
 455             }
 456         }
 457     }
 458
 459     /* Somone has used write_fork, we assume file was changed, register it to file change event api */
 460     if (ofork->of_flags & AFPFORK_MODIFIED) {
 461         fce_register_file_modification(ofork);
 462     }
 463
 464     ret = 0;
 465     if ( ad_close( ofork->of_ad, adflags ) < 0 ) {
 466         ret = -1;
 467     }
 468
 469     of_dealloc( ofork );
 470     return ret;
 471 }
 472
 473 /* ----------------------
 474
 475 */
 476 struct adouble *of_ad(const struct vol *vol, struct path *path, struct adouble *ad)
 477 {
 478     struct ofork        *of;
 479     struct adouble      *adp;
 480
 481     if ((of = of_findname(path))) {
 482         adp = of->of_ad;
 483     } else {
 484         ad_init(ad, vol->v_adouble, vol->v_ad_options);
 485         adp = ad;
 486     }
 487     return adp;
 488 }
 489
 490 /* ----------------------
 491    close all forks for a volume
 492 */
 493 void of_closevol(const struct vol *vol)
 494 {
 495     int refnum;
 496
 497     if (!oforks)
 498         return;
 499
 500     for ( refnum = 0; refnum < nforks; refnum++ ) {
 501         if (oforks[ refnum ] != NULL && oforks[refnum]->of_vol == vol) {
 502             if (of_closefork( oforks[ refnum ]) < 0 ) {
 503                 LOG(log_error, logtype_afpd, "of_closevol: %s", strerror(errno) );
 504             }
 505         }
 506     }
 507     return;
 508 }
 509