src/tools/dumpscan/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 = strdup("/");
 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         return 0;
 290     }
 291
 292     *his_path = 0;
 293     vhe = get_vhash_ent(phi, vnode, 0);
 294     if (!vhe) {
 295         if (phi->p->cb_error)
 296             (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 297                                 "Vnode %d not found in hash table", vnode);
 298         return DSERR_FMT;
 299     }
 300     while (vnode != 1) {
 301         /* Find the parent */
 302         if (!vhe->parent) {
 303             if (phi->p->cb_error)
 304                 (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 305                                     "Vnode %d has no parent?", vnode);
 306             if (path)
 307                 free(path);
 308             return DSERR_FMT;
 309         }
 310         parent = vhe->parent;
 311         vhe = get_vhash_ent(phi, parent, 0);
 312         if (phi->p->print_flags & DSPRINT_DEBUG)
 313             fprintf(stderr, "Searching for vnode %d in parent %d\n", vnode,
 314                     parent);
 315         if (!vhe) {
 316             if (phi->p->cb_error)
 317                 (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 318                                     "Vnode %d not found in hash table",
 319                                     parent);
 320             if (path)
 321                 free(path);
 322             return DSERR_FMT;
 323         }
 324
 325         if (fast) {
 326             /* Make up a path component from the vnode number */
 327             sprintf(fastbuf, "%d", vnode);
 328             name = fastbuf;
 329         } else {
 330             /* Do a reverse-lookup in the parent directory */
 331             if (zero64(vhe->d_offset)) {
 332                 if (phi->p->cb_error)
 333                     (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 334                                         "Directory vnode %d is incomplete",
 335                                         parent);
 336                 if (path)
 337                     free(path);
 338                 return DSERR_FMT;
 339             }
 340             if ((r = xfseek(X, &vhe->d_offset))) {
 341                 if (phi->p->cb_error)
 342                     (phi->p->cb_error) (errno, 1, phi->p->err_refcon,
 343                                         "Unable to seek to directory %d",
 344                                         parent);
 345                 if (path)
 346                     free(path);
 347                 return r;
 348             }
 349
 350             name = 0;
 351             r = DirectoryLookup(X, phi->p, vhe->d_size, &name, &vnode, 0);
 352             if (r)
 353                 return r;
 354             if (!name) {
 355                 if (phi->p->cb_error)
 356                     (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 357                                         "No entry for vnode %d in directory %d",
 358                                         vnode, parent);
 359                 if (path)
 360                     free(path);
 361                 return ENOENT;
 362             }
 363         }
 364
 365         nl = strlen(name);
 366         if (path) {
 367             path = (char *)realloc(path, nl + pl + 2);
 368             if (!path) {
 369                 if (phi->p->cb_error)
 370                     (phi->p->cb_error) (ENOMEM, 1, phi->p->err_refcon,
 371                                         "No memory for pathname of vnode 1");
 372                 return ENOMEM;
 373             }
 374             x = path + pl;
 375             y = x + nl + 1;
 376             while (x >= path)
 377                 *y-- = *x--;
 378             path[0] = '/';
 379             for (x = name, y = path + 1; *x;)
 380                 *y++ = *x++;
 381             pl += nl + 1;
 382         } else {
 383             path = (char *)malloc(nl + 2);
 384             if (!path) {
 385                 if (phi->p->cb_error)
 386                     (phi->p->cb_error) (ENOMEM, 1, phi->p->err_refcon,
 387                                         "No memory for pathname of vnode 1");
 388                 return ENOMEM;
 389             }
 390             path[0] = '/';
 391             strcpy(path + 1, name);
 392             pl = nl + 1;
 393         }
 394         if (!fast)
 395             free(name);
 396         vnode = parent;
 397     }
 398     *his_path = path;
 399     return 0;
 400 }