src/tests/pathname.c

   1 /*
   2  * CMUCS AFStools
   3  * dumpscan - routines for scanning and manipulating AFS volume dumps
   4  *
   5  * Copyright (c) 1998 Carnegie Mellon University
   6  * All Rights Reserved.
   7  *
   8  * Permission to use, copy, modify and distribute this software and its
   9  * documentation is hereby granted, provided that both the copyright
  10  * notice and this permission notice appear in all copies of the
  11  * software, derivative works or modified versions, and any portions
  12  * thereof, and that both notices appear in supporting documentation.
  13  *
  14  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  15  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  16  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  17  *
  18  * Carnegie Mellon requests users of this software to return to
  19  *
  20  *  Software Distribution Coordinator  or  Software_Distribution@CS.CMU.EDU
  21  *  School of Computer Science
  22  *  Carnegie Mellon University
  23  *  Pittsburgh PA 15213-3890
  24  *
  25  * any improvements or extensions that they make and grant Carnegie Mellon
  26  * the rights to redistribute these changes.
  27  */
  28
  29 /* pathname.c - Pathname lookup and traversal */
  30
  31 #include <errno.h>
  32 #include <string.h>
  33
  34 #include "dumpscan.h"
  35 #include "dumpscan_errs.h"
  36
  37 /* Hash function for a vnode */
  38 #define BUCKET_SIZE 32
  39 #define vnode_hash(phi,vnode) ((vnode) & ((1 << (phi)->hash_size) - 1))
  40
  41
  42 static vhash_ent *
  43 get_vhash_ent(path_hashinfo * phi, afs_uint32 vnode, int make)
  44 {
  45     int key = vnode_hash(phi, vnode);
  46     vhash_ent *vhe;
  47
  48     for (vhe = phi->hash_table[key]; vhe && vhe->vnode != vnode;
  49          vhe = vhe->next);
  50     if (make && !vhe) {
  51         vhe = (vhash_ent *) malloc(sizeof(vhash_ent));
  52         if (vhe) {
  53             memset(vhe, 0, sizeof(vhash_ent));
  54             vhe->vnode = vnode;
  55             vhe->next = phi->hash_table[key];
  56             phi->hash_table[key] = vhe;
  57         }
  58     }
  59     return vhe;
  60 }
  61
  62
  63 static afs_uint32
  64 volhdr_cb(afs_vol_header * hdr, XFILE * X, void *refcon)
  65 {
  66     path_hashinfo *phi = (path_hashinfo *) refcon;
  67     int nfiles, hsize;
  68
  69     if (hdr->field_mask & F_VOLHDR_NFILES) {
  70         nfiles = phi->n_vnodes = hdr->nfiles;
  71         for (phi->hash_size = 1; nfiles > BUCKET_SIZE;
  72              phi->hash_size++, nfiles >>= 1);
  73         hsize = (1 << phi->hash_size);
  74         phi->hash_table = (vhash_ent **) malloc(hsize * sizeof(vhash_ent *));
  75         if (!phi->hash_table)
  76             return ENOMEM;
  77         memset(phi->hash_table, 0, hsize * sizeof(vhash_ent *));
  78         return 0;
  79     } else {
  80         if (phi->p->cb_error)
  81             (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
  82                                 "File count missing from volume header");
  83         return DSERR_FMT;
  84     }
  85 }
  86
  87
  88 static afs_uint32
  89 vnode_keep(afs_vnode * v, XFILE * X, void *refcon)
  90 {
  91     path_hashinfo *phi = (path_hashinfo *) refcon;
  92     vhash_ent *vhe;
  93
  94     if (!phi->hash_table) {
  95         if (phi->p->cb_error)
  96             (phi->p->cb_error) (DSERR_FMT, 1, phi->p->refcon,
  97                                 "No volume header in dump???");
  98         return DSERR_FMT;
  99     }
 100     vhe = get_vhash_ent(phi, v->vnode, 1);
 101     if (!vhe)
 102         return ENOMEM;
 103     cp64(vhe->v_offset, v->offset);
 104     if (v->field_mask & F_VNODE_PARENT)
 105         vhe->parent = v->parent;
 106     if (v->field_mask & F_VNODE_DATA) {
 107         cp64(vhe->d_offset, v->d_offset);
 108         vhe->d_size = v->size;
 109     }
 110     if ((v->field_mask & F_VNODE_TYPE) && v->type == vDirectory)
 111         phi->n_dirs++;
 112     else
 113         phi->n_files++;
 114     return 0;
 115 }
 116
 117
 118 static afs_uint32
 119 vnode_stop(afs_vnode * v, XFILE * X, void *refcon)
 120 {
 121     path_hashinfo *phi = (path_hashinfo *) refcon;
 122     int r;
 123
 124     /* If the file is seekable, try to position so we can pick up later... */
 125     if (phi->p->flags & DSFLAG_SEEK)
 126       if ((r = xfseek(X, &v->offset)))
 127             return r;
 128     return DSERR_DONE;
 129 }
 130
 131
 132 static afs_uint32
 133 dirent_cb(afs_vnode * v, afs_dir_entry * de, XFILE * X, void *refcon)
 134 {
 135     path_hashinfo *phi = (path_hashinfo *) refcon;
 136     vhash_ent *vhe;
 137
 138     if (!phi->hash_table) {
 139         if (phi->p->cb_error)
 140             (phi->p->cb_error) (DSERR_FMT, 1, phi->p->refcon,
 141                                 "No volume header in dump???");
 142         return DSERR_FMT;
 143     }
 144     if (!strcmp(de->name, ".") || !strcmp(de->name, ".."))
 145         return 0;
 146     vhe = get_vhash_ent(phi, de->vnode, 1);
 147     if (!vhe)
 148         return ENOMEM;
 149     vhe->parent = v->vnode;
 150     return 0;
 151 }
 152
 153
 154 /* Prescan the vnodes in a dump file, collecting information that will
 155  * be useful in generating and following pathnames.
 156  */
 157 afs_uint32
 158 Path_PreScan(XFILE * X, path_hashinfo * phi, int full)
 159 {
 160     dump_parser my_p, *p = phi->p;
 161
 162     memset(phi, 0, sizeof(path_hashinfo));
 163     phi->p = p;
 164     memset(&my_p, 0, sizeof(my_p));
 165     my_p.refcon = (void *)phi;
 166     my_p.cb_volhdr = volhdr_cb;
 167     my_p.cb_vnode_dir = vnode_keep;
 168     if (full) {
 169         my_p.cb_vnode_file = vnode_keep;
 170         my_p.cb_vnode_link = vnode_keep;
 171         my_p.cb_vnode_empty = vnode_keep;
 172         my_p.cb_vnode_wierd = vnode_keep;
 173     } else {
 174         my_p.cb_vnode_file = vnode_stop;
 175         my_p.cb_vnode_link = vnode_stop;
 176         my_p.cb_vnode_empty = vnode_stop;
 177         my_p.cb_vnode_wierd = vnode_stop;
 178     }
 179     my_p.err_refcon = p->err_refcon;
 180     my_p.cb_error = p->cb_error;
 181     my_p.cb_dirent = dirent_cb;
 182     my_p.flags = p->flags;
 183     my_p.print_flags = p->print_flags;
 184     my_p.repair_flags = p->repair_flags;
 185
 186     return ParseDumpFile(X, &my_p);
 187 }
 188
 189
 190 /* Free the hash table in a path_hashinfo */
 191 void
 192 Path_FreeHashTable(path_hashinfo * phi)
 193 {
 194     int i, size;
 195     vhash_ent *vhe, *next_vhe;
 196
 197     if (phi->hash_table) {
 198         size = (1 << phi->hash_size);
 199         for (i = 0; i < size; i++)
 200             for (vhe = phi->hash_table[i]; vhe; vhe = next_vhe) {
 201                 next_vhe = vhe->next;
 202                 free(vhe);
 203             }
 204         free(phi->hash_table);
 205     }
 206 }
 207
 208
 209 /* Follow a pathname to the vnode it represents */
 210 afs_uint32
 211 Path_Follow(XFILE * X, path_hashinfo * phi, char *path, vhash_ent * his_vhe)
 212 {
 213     vhash_ent *vhe;
 214     char *name;
 215     afs_uint32 r, vnum = 1;
 216
 217     if (*path == '/')
 218         path++;
 219     name = strtok(path, "/");
 220
 221     for (name = strtok(path, "/"); name; name = strtok(0, "/")) {
 222         if (!(vnum & 1)) {
 223             if (phi->p->cb_error)
 224                 (phi->p->cb_error) (ENOTDIR, 1, phi->p->err_refcon,
 225                                     "Not a directory vnode");
 226             return ENOTDIR;
 227         }
 228         vhe = get_vhash_ent(phi, vnum, 0);
 229         if (!vhe) {
 230             if (phi->p->cb_error)
 231                 (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 232                                     "Vnode %d not found in hash table", vnum);
 233             return DSERR_FMT;
 234         }
 235         if (zero64(vhe->d_offset)) {
 236             if (phi->p->cb_error)
 237                 (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 238                                     "Directory vnode %d is incomplete", vnum);
 239             return DSERR_FMT;
 240         }
 241         if ((r = xfseek(X, &vhe->d_offset))) {
 242             if (phi->p->cb_error)
 243                 (phi->p->cb_error) (r, 1, phi->p->err_refcon,
 244                                     "Unable to seek to directory %d", vnum);
 245             return r;
 246         }
 247         vnum = 0;
 248         r = DirectoryLookup(X, phi->p, vhe->d_size, &name, &vnum, 0);
 249         if (r)
 250             return r;
 251         if (!vnum) {
 252             if (phi->p->cb_error)
 253                 (phi->p->cb_error) (ENOENT, 1, phi->p->err_refcon,
 254                                     "No such vnode");
 255             return ENOENT;
 256         }
 257     }
 258     vhe = get_vhash_ent(phi, vnum, 0);
 259     if (!vhe) {
 260         if (phi->p->cb_error)
 261             (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 262                                 "Vnode %d not found in hash table", vnum);
 263         return DSERR_FMT;
 264     }
 265     if (his_vhe)
 266         *his_vhe = *vhe;
 267     return 0;
 268 }
 269
 270
 271 afs_uint32
 272 Path_Build(XFILE * X, path_hashinfo * phi, afs_uint32 vnode, char **his_path,
 273            int fast)
 274 {
 275     vhash_ent *vhe;
 276     char *name, *path = 0, fastbuf[12];
 277     char *x, *y;
 278     afs_uint32 parent, r;
 279     int nl, pl = 0;
 280
 281     if (vnode == 1) {
 282         *his_path = (char *)malloc(2);
 283         if (!his_path) {
 284             if (phi->p->cb_error)
 285                 (phi->p->cb_error) (ENOMEM, 1, phi->p->err_refcon,
 286                                     "No memory for pathname of vnode 1");
 287             return ENOMEM;
 288         }
 289         strcpy(*his_path, "/");
 290         return 0;
 291     }
 292
 293     *his_path = 0;
 294     vhe = get_vhash_ent(phi, vnode, 0);
 295     if (!vhe) {
 296         if (phi->p->cb_error)
 297             (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 298                                 "Vnode %d not found in hash table", vnode);
 299         return DSERR_FMT;
 300     }
 301     while (vnode != 1) {
 302         /* Find the parent */
 303         if (!vhe->parent) {
 304             if (phi->p->cb_error)
 305                 (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 306                                     "Vnode %d has no parent?", vnode);
 307             if (path)
 308                 free(path);
 309             return DSERR_FMT;
 310         }
 311         parent = vhe->parent;
 312         vhe = get_vhash_ent(phi, parent, 0);
 313         if (phi->p->print_flags & DSPRINT_DEBUG)
 314             fprintf(stderr, "Searching for vnode %d in parent %d\n", vnode,
 315                     parent);
 316         if (!vhe) {
 317             if (phi->p->cb_error)
 318                 (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 319                                     "Vnode %d not found in hash table",
 320                                     parent);
 321             if (path)
 322                 free(path);
 323             return DSERR_FMT;
 324         }
 325
 326         if (fast) {
 327             /* Make up a path component from the vnode number */
 328             sprintf(fastbuf, "%d", vnode);
 329             name = fastbuf;
 330         } else {
 331             /* Do a reverse-lookup in the parent directory */
 332             if (zero64(vhe->d_offset)) {
 333                 if (phi->p->cb_error)
 334                     (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 335                                         "Directory vnode %d is incomplete",
 336                                         parent);
 337                 if (path)
 338                     free(path);
 339                 return DSERR_FMT;
 340             }
 341             if ((r = xfseek(X, &vhe->d_offset))) {
 342                 if (phi->p->cb_error)
 343                     (phi->p->cb_error) (errno, 1, phi->p->err_refcon,
 344                                         "Unable to seek to directory %d",
 345                                         parent);
 346                 if (path)
 347                     free(path);
 348                 return r;
 349             }
 350
 351             name = 0;
 352             r = DirectoryLookup(X, phi->p, vhe->d_size, &name, &vnode, 0);
 353             if (r)
 354                 return r;
 355             if (!name) {
 356                 if (phi->p->cb_error)
 357                     (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 358                                         "No entry for vnode %d in directory %d",
 359                                         vnode, parent);
 360                 if (path)
 361                     free(path);
 362                 return ENOENT;
 363             }
 364         }
 365
 366         nl = strlen(name);
 367         if (path) {
 368             path = (char *)realloc(path, nl + pl + 2);
 369             if (!path) {
 370                 if (phi->p->cb_error)
 371                     (phi->p->cb_error) (ENOMEM, 1, phi->p->err_refcon,
 372                                         "No memory for pathname of vnode 1");
 373                 return ENOMEM;
 374             }
 375             x = path + pl;
 376             y = x + nl + 1;
 377             while (x >= path)
 378                 *y-- = *x--;
 379             path[0] = '/';
 380             for (x = name, y = path + 1; *x;)
 381                 *y++ = *x++;
 382             pl += nl + 1;
 383         } else {
 384             path = (char *)malloc(nl + 2);
 385             if (!path) {
 386                 if (phi->p->cb_error)
 387                     (phi->p->cb_error) (ENOMEM, 1, phi->p->err_refcon,
 388                                         "No memory for pathname of vnode 1");
 389                 return ENOMEM;
 390             }
 391             path[0] = '/';
 392             strcpy(path + 1, name);
 393             pl = nl + 1;
 394         }
 395         if (!fast)
 396             free(name);
 397         vnode = parent;
 398     }
 399     *his_path = path;
 400     return 0;
 401 }