etc/afpd/ofork.c

   1 /*
   2  * $Id: ofork.c,v 1.5 2001-08-15 01:37:34 srittau 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 #include <string.h>
  15 #include <sys/stat.h> /* works around a bug */
  16 #include <sys/param.h>
  17 #include <syslog.h>
  18 #include <errno.h>
  19
  20 #include <atalk/adouble.h>
  21
  22 #include "globals.h"
  23 #include "volume.h"
  24 #include "directory.h"
  25 #include "fork.h"
  26
  27 /* we need to have a hashed list of oforks (by name). just hash
  28  * by first letter. */
  29 #define OFORK_HASHSIZE  64
  30 static struct ofork     *ofork_table[OFORK_HASHSIZE];
  31
  32 static struct ofork     **oforks = NULL;
  33 static int              nforks = 0;
  34 static u_short          lastrefnum = 0;
  35
  36
  37 /* OR some of each character for the hash*/
  38 static __inline__ unsigned long hashfn(const char *name)
  39 {
  40   unsigned long i = 0;
  41
  42   while (*name) {
  43     i = ((i << 4) | (8*sizeof(i) - 4)) ^ *name++;
  44   }
  45   return i & (OFORK_HASHSIZE - 1);
  46 }
  47
  48 static __inline__ void of_hash(struct ofork *of)
  49 {
  50   struct ofork **table;
  51
  52   table = &ofork_table[hashfn(of->of_name)];
  53   if ((of->next = *table) != NULL)
  54     (*table)->prevp = &of->next;
  55   *table = of;
  56   of->prevp = table;
  57 }
  58
  59 static __inline__ void of_unhash(struct ofork *of)
  60 {
  61   if (of->prevp) {
  62     if (of->next)
  63       of->next->prevp = of->prevp;
  64     *(of->prevp) = of->next;
  65   }
  66 }
  67
  68 void of_pforkdesc( f )
  69     FILE        *f;
  70 {
  71     u_short     ofrefnum;
  72
  73     if (!oforks)
  74       return;
  75
  76     for ( ofrefnum = 0; ofrefnum < nforks; ofrefnum++ ) {
  77         if ( oforks[ ofrefnum ] != NULL ) {
  78             fprintf( f, "%hu <%s>\n", ofrefnum, oforks[ ofrefnum ]->of_name);
  79         }
  80     }
  81 }
  82
  83 int of_flush(const struct vol *vol)
  84 {
  85     u_int16_t   refnum;
  86
  87     if (!oforks)
  88       return 0;
  89
  90     for ( refnum = 0; refnum < nforks; refnum++ ) {
  91         if (oforks[ refnum ] != NULL && (oforks[refnum]->of_vol == vol) &&
  92              flushfork( oforks[ refnum ] ) < 0 ) {
  93             syslog( LOG_ERR, "of_flush: %s", strerror(errno) );
  94         }
  95     }
  96     return( 0 );
  97 }
  98
  99
 100 int of_rename(vol, olddir, oldpath, newdir, newpath)
 101      const struct vol *vol;
 102      struct dir *olddir, *newdir;
 103      const char *oldpath, *newpath;
 104 {
 105   struct ofork *of, *next, *d_ofork;
 106
 107   next = ofork_table[hashfn(oldpath)];
 108   while ((of = next)) {
 109     next = next->next; /* so we can unhash and still be all right. */
 110
 111     if ((vol == of->of_vol) && (olddir == of->of_dir) &&
 112         (strcmp(of->of_name, oldpath) == 0)) {
 113       of_unhash(of);
 114       strncpy( of->of_name, newpath, of->of_namelen);
 115       of->of_d_prev->of_d_next = of->of_d_prev;
 116       of->of_d_next->of_d_prev = of->of_d_next;
 117       of->of_dir = newdir;
 118       if (!(d_ofork = newdir->d_ofork)) {
 119         newdir->d_ofork = of;
 120         of->of_d_next = of->of_d_prev = of;
 121       } else {
 122         of->of_d_next = d_ofork;
 123         of->of_d_prev = d_ofork->of_d_prev;
 124         of->of_d_prev->of_d_next = of;
 125         d_ofork->of_d_prev = of;
 126       }
 127       of_hash(of);
 128     }
 129   }
 130
 131   return AFP_OK;
 132 }
 133
 134     struct ofork *
 135 of_alloc(vol, dir, path, ofrefnum, eid, ad)
 136     struct vol          *vol;
 137     struct dir          *dir;
 138     char                *path;
 139     u_int16_t           *ofrefnum;
 140     const int           eid;
 141     struct adouble      *ad;
 142 {
 143     struct ofork        *of, *d_ofork;
 144     u_int16_t           refnum, of_refnum;
 145
 146     int                 i;
 147
 148     if (!oforks) {
 149       nforks = (getdtablesize() - 10) / 2;
 150       oforks = (struct ofork **) calloc(nforks, sizeof(struct ofork *));
 151       if (!oforks)
 152         return NULL;
 153     }
 154
 155     for ( refnum = lastrefnum++, i = 0; i < nforks; i++, refnum++ ) {
 156         if ( oforks[ refnum % nforks ] == NULL ) {
 157             break;
 158         }
 159     }
 160     if ( i == nforks ) {
 161         syslog(LOG_ERR, "of_alloc: maximum number of forks exceeded.");
 162         return( NULL );
 163     }
 164
 165     of_refnum = refnum % nforks;
 166     if (( oforks[ of_refnum ] =
 167             (struct ofork *)malloc( sizeof( struct ofork ))) == NULL ) {
 168         syslog( LOG_ERR, "of_alloc: malloc: %s", strerror(errno) );
 169         return NULL;
 170     }
 171     of = oforks[of_refnum];
 172
 173     /* see if we need to allocate space for the adouble struct */
 174     if (!ad) {
 175         ad = malloc( sizeof( struct adouble ) );
 176         if (!ad) {
 177             syslog( LOG_ERR, "of_alloc: malloc: %s", strerror(errno) );
 178             return NULL;
 179         }
 180
 181         /* initialize to zero. This is important to ensure that
 182            ad_open really does reinitialize the structure. */
 183         memset( ad, 0, sizeof( struct adouble ) );
 184     } else {
 185         /* Increase the refcount on this struct adouble. This is
 186            decremented again in oforc_dealloc. */
 187         ad->ad_refcount++;
 188     }
 189
 190     of->of_ad = ad;
 191
 192     of->of_vol = vol;
 193     of->of_dir = dir;
 194
 195     if (!(d_ofork = dir->d_ofork)) {
 196       dir->d_ofork = of;
 197       of->of_d_next = of->of_d_prev = of;
 198     } else {
 199       of->of_d_next = d_ofork;
 200       of->of_d_prev = d_ofork->of_d_prev;
 201       d_ofork->of_d_prev->of_d_next = of;
 202       d_ofork->of_d_prev = of;
 203     }
 204
 205     /* here's the deal: we allocate enough for the standard mac file length.
 206      * in the future, we'll reallocate in fairly large jumps in case
 207      * of long unicode names */
 208     if (( of->of_name =(char *)malloc(MACFILELEN + 1)) ==
 209         NULL ) {
 210         syslog( LOG_ERR, "of_alloc: malloc: %s", strerror(errno) );
 211         if (!ad)
 212           free(of->of_ad);
 213         free(of);
 214         oforks[ of_refnum ] = NULL;
 215         return NULL;
 216     }
 217     strncpy( of->of_name, path, of->of_namelen = MACFILELEN + 1);
 218     *ofrefnum = refnum;
 219     of->of_refnum = of_refnum;
 220     of_hash(of);
 221
 222     if (eid == ADEID_DFORK)
 223       of->of_flags = AFPFORK_DATA;
 224     else
 225       of->of_flags = AFPFORK_RSRC;
 226
 227     return( of );
 228 }
 229
 230 struct ofork *of_find(const u_int16_t ofrefnum )
 231 {
 232    if (!oforks)
 233      return NULL;
 234
 235     return( oforks[ ofrefnum % nforks ] );
 236 }
 237
 238 struct ofork *
 239 of_findname(const struct vol *vol, const struct dir *dir, const char *name)
 240 {
 241     struct ofork *of;
 242
 243     for (of = ofork_table[hashfn(name)]; of; of = of->next) {
 244       if ((vol == of->of_vol) && (dir == of->of_dir) &&
 245           (strcmp(of->of_name, name) == 0))
 246         return of;
 247     }
 248
 249     return NULL;
 250 }
 251
 252
 253 void of_dealloc( of )
 254     struct ofork        *of;
 255 {
 256     if (!oforks)
 257       return;
 258
 259     of_unhash(of);
 260
 261     /* detach ofork */
 262     of->of_d_prev->of_d_next = of->of_d_next;
 263     of->of_d_next->of_d_prev = of->of_d_prev;
 264     if (of->of_dir->d_ofork == of) {
 265       of->of_dir->d_ofork = (of == of->of_d_next) ? NULL : of->of_d_next;
 266     }
 267
 268     oforks[ of->of_refnum ] = NULL;
 269     free( of->of_name );
 270
 271     /* decrease refcount */
 272     of->of_ad->ad_refcount--;
 273
 274     if ( of->of_ad->ad_refcount <= 0) {
 275       free( of->of_ad);
 276     } else {/* someone's still using it. just free this user's locks */
 277       ad_unlock(of->of_ad, of->of_refnum);
 278     }
 279
 280     free( of );
 281 }