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 = calloc(1, sizeof(vhash_ent));
  52         if (vhe) {
  53             vhe->vnode = vnode;
  54             vhe->next = phi->hash_table[key];
  55             phi->hash_table[key] = vhe;
  56         }
  57     }
  58     return vhe;
  59 }
  60
  61
  62 static afs_uint32
  63 volhdr_cb(afs_vol_header * hdr, XFILE * X, void *refcon)
  64 {
  65     path_hashinfo *phi = (path_hashinfo *) refcon;
  66     int nfiles, hsize;
  67
  68     if (hdr->field_mask & F_VOLHDR_NFILES) {
  69         nfiles = phi->n_vnodes = hdr->nfiles;
  70         for (phi->hash_size = 1; nfiles > BUCKET_SIZE;
  71              phi->hash_size++, nfiles >>= 1);
  72         hsize = (1 << phi->hash_size);
  73         phi->hash_table = calloc(hsize ,sizeof(vhash_ent *));
  74         if (!phi->hash_table)
  75             return ENOMEM;
  76         return 0;
  77     } else {
  78         if (phi->p->cb_error)
  79             (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
  80                                 "File count missing from volume header");
  81         return DSERR_FMT;
  82     }
  83 }
  84
  85
  86 static afs_uint32
  87 vnode_keep(afs_vnode * v, XFILE * X, void *refcon)
  88 {
  89     path_hashinfo *phi = (path_hashinfo *) refcon;
  90     vhash_ent *vhe;
  91
  92     if (!phi->hash_table) {
  93         if (phi->p->cb_error)
  94             (phi->p->cb_error) (DSERR_FMT, 1, phi->p->refcon,
  95                                 "No volume header in dump???");
  96         return DSERR_FMT;
  97     }
  98     vhe = get_vhash_ent(phi, v->vnode, 1);
  99     if (!vhe)
 100         return ENOMEM;
 101     cp64(vhe->v_offset, v->offset);
 102     if (v->field_mask & F_VNODE_PARENT)
 103         vhe->parent = v->parent;
 104     if (v->field_mask & F_VNODE_DATA) {
 105         cp64(vhe->d_offset, v->d_offset);
 106         vhe->d_size = v->size;
 107     }
 108     if ((v->field_mask & F_VNODE_TYPE) && v->type == vDirectory)
 109         phi->n_dirs++;
 110     else
 111         phi->n_files++;
 112     return 0;
 113 }
 114
 115
 116 static afs_uint32
 117 vnode_stop(afs_vnode * v, XFILE * X, void *refcon)
 118 {
 119     path_hashinfo *phi = (path_hashinfo *) refcon;
 120     int r;
 121
 122     /* If the file is seekable, try to position so we can pick up later... */
 123     if (phi->p->flags & DSFLAG_SEEK)
 124       if ((r = xfseek(X, &v->offset)))
 125             return r;
 126     return DSERR_DONE;
 127 }
 128
 129
 130 static afs_uint32
 131 dirent_cb(afs_vnode * v, afs_dir_entry * de, XFILE * X, void *refcon)
 132 {
 133     path_hashinfo *phi = (path_hashinfo *) refcon;
 134     vhash_ent *vhe;
 135
 136     if (!phi->hash_table) {
 137         if (phi->p->cb_error)
 138             (phi->p->cb_error) (DSERR_FMT, 1, phi->p->refcon,
 139                                 "No volume header in dump???");
 140         return DSERR_FMT;
 141     }
 142     if (!strcmp(de->name, ".") || !strcmp(de->name, ".."))
 143         return 0;
 144     vhe = get_vhash_ent(phi, de->vnode, 1);
 145     if (!vhe)
 146         return ENOMEM;
 147     vhe->parent = v->vnode;
 148     return 0;
 149 }
 150
 151
 152 /* Prescan the vnodes in a dump file, collecting information that will
 153  * be useful in generating and following pathnames.
 154  */
 155 afs_uint32
 156 Path_PreScan(XFILE * X, path_hashinfo * phi, int full)
 157 {
 158     dump_parser my_p, *p = phi->p;
 159
 160     memset(phi, 0, sizeof(path_hashinfo));
 161     phi->p = p;
 162     memset(&my_p, 0, sizeof(my_p));
 163     my_p.refcon = (void *)phi;
 164     my_p.cb_volhdr = volhdr_cb;
 165     my_p.cb_vnode_dir = vnode_keep;
 166     if (full) {
 167         my_p.cb_vnode_file = vnode_keep;
 168         my_p.cb_vnode_link = vnode_keep;
 169         my_p.cb_vnode_empty = vnode_keep;
 170         my_p.cb_vnode_wierd = vnode_keep;
 171     } else {
 172         my_p.cb_vnode_file = vnode_stop;
 173         my_p.cb_vnode_link = vnode_stop;
 174         my_p.cb_vnode_empty = vnode_stop;
 175         my_p.cb_vnode_wierd = vnode_stop;
 176     }
 177     my_p.err_refcon = p->err_refcon;
 178     my_p.cb_error = p->cb_error;
 179     my_p.cb_dirent = dirent_cb;
 180     my_p.flags = p->flags;
 181     my_p.print_flags = p->print_flags;
 182     my_p.repair_flags = p->repair_flags;
 183
 184     return ParseDumpFile(X, &my_p);
 185 }
 186
 187
 188 /* Free the hash table in a path_hashinfo */
 189 void
 190 Path_FreeHashTable(path_hashinfo * phi)
 191 {
 192     int i, size;
 193     vhash_ent *vhe, *next_vhe;
 194
 195     if (phi->hash_table) {
 196         size = (1 << phi->hash_size);
 197         for (i = 0; i < size; i++)
 198             for (vhe = phi->hash_table[i]; vhe; vhe = next_vhe) {
 199                 next_vhe = vhe->next;
 200                 free(vhe);
 201             }
 202         free(phi->hash_table);
 203     }
 204 }
 205
 206
 207 /* Follow a pathname to the vnode it represents */
 208 afs_uint32
 209 Path_Follow(XFILE * X, path_hashinfo * phi, char *path, vhash_ent * his_vhe)
 210 {
 211     vhash_ent *vhe;
 212     char *name;
 213     afs_uint32 r, vnum = 1;
 214
 215     if (*path == '/')
 216         path++;
 217     name = strtok(path, "/");
 218
 219     for (name = strtok(path, "/"); name; name = strtok(0, "/")) {
 220         if (!(vnum & 1)) {
 221             if (phi->p->cb_error)
 222                 (phi->p->cb_error) (ENOTDIR, 1, phi->p->err_refcon,
 223                                     "Not a directory vnode");
 224             return ENOTDIR;
 225         }
 226         vhe = get_vhash_ent(phi, vnum, 0);
 227         if (!vhe) {
 228             if (phi->p->cb_error)
 229                 (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 230                                     "Vnode %d not found in hash table", vnum);
 231             return DSERR_FMT;
 232         }
 233         if (zero64(vhe->d_offset)) {
 234             if (phi->p->cb_error)
 235                 (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 236                                     "Directory vnode %d is incomplete", vnum);
 237             return DSERR_FMT;
 238         }
 239         if ((r = xfseek(X, &vhe->d_offset))) {
 240             if (phi->p->cb_error)
 241                 (phi->p->cb_error) (r, 1, phi->p->err_refcon,
 242                                     "Unable to seek to directory %d", vnum);
 243             return r;
 244         }
 245         vnum = 0;
 246         r = DirectoryLookup(X, phi->p, vhe->d_size, &name, &vnum, 0);
 247         if (r)
 248             return r;
 249         if (!vnum) {
 250             if (phi->p->cb_error)
 251                 (phi->p->cb_error) (ENOENT, 1, phi->p->err_refcon,
 252                                     "No such vnode");
 253             return ENOENT;
 254         }
 255     }
 256     vhe = get_vhash_ent(phi, vnum, 0);
 257     if (!vhe) {
 258         if (phi->p->cb_error)
 259             (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 260                                 "Vnode %d not found in hash table", vnum);
 261         return DSERR_FMT;
 262     }
 263     if (his_vhe)
 264         *his_vhe = *vhe;
 265     return 0;
 266 }
 267
 268
 269 afs_uint32
 270 Path_Build(XFILE * X, path_hashinfo * phi, afs_uint32 vnode, char **his_path,
 271            int fast)
 272 {
 273     vhash_ent *vhe;
 274     char *name, *path = 0, fastbuf[12];
 275     char *x, *y;
 276     afs_uint32 parent, r;
 277     int nl, pl = 0;
 278
 279     if (vnode == 1) {
 280         *his_path = strdup("/");
 281         if (!*his_path) {
 282             if (phi->p->cb_error)
 283                 (phi->p->cb_error) (ENOMEM, 1, phi->p->err_refcon,
 284                                     "No memory for pathname of vnode 1");
 285             return ENOMEM;
 286         }
 287         return 0;
 288     }
 289
 290     *his_path = 0;
 291     vhe = get_vhash_ent(phi, vnode, 0);
 292     if (!vhe) {
 293         if (phi->p->cb_error)
 294             (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 295                                 "Vnode %d not found in hash table", vnode);
 296         return DSERR_FMT;
 297     }
 298     while (vnode != 1) {
 299         /* Find the parent */
 300         if (!vhe->parent) {
 301             if (phi->p->cb_error)
 302                 (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 303                                     "Vnode %d has no parent?", vnode);
 304             if (path)
 305                 free(path);
 306             return DSERR_FMT;
 307         }
 308         parent = vhe->parent;
 309         vhe = get_vhash_ent(phi, parent, 0);
 310         if (phi->p->print_flags & DSPRINT_DEBUG)
 311             fprintf(stderr, "Searching for vnode %d in parent %d\n", vnode,
 312                     parent);
 313         if (!vhe) {
 314             if (phi->p->cb_error)
 315                 (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 316                                     "Vnode %d not found in hash table",
 317                                     parent);
 318             if (path)
 319                 free(path);
 320             return DSERR_FMT;
 321         }
 322
 323         if (fast) {
 324             /* Make up a path component from the vnode number */
 325             sprintf(fastbuf, "%d", vnode);
 326             name = fastbuf;
 327         } else {
 328             /* Do a reverse-lookup in the parent directory */
 329             if (zero64(vhe->d_offset)) {
 330                 if (phi->p->cb_error)
 331                     (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 332                                         "Directory vnode %d is incomplete",
 333                                         parent);
 334                 if (path)
 335                     free(path);
 336                 return DSERR_FMT;
 337             }
 338             if ((r = xfseek(X, &vhe->d_offset))) {
 339                 if (phi->p->cb_error)
 340                     (phi->p->cb_error) (errno, 1, phi->p->err_refcon,
 341                                         "Unable to seek to directory %d",
 342                                         parent);
 343                 if (path)
 344                     free(path);
 345                 return r;
 346             }
 347
 348             name = 0;
 349             r = DirectoryLookup(X, phi->p, vhe->d_size, &name, &vnode, 0);
 350             if (r)
 351                 return r;
 352             if (!name) {
 353                 if (phi->p->cb_error)
 354                     (phi->p->cb_error) (DSERR_FMT, 1, phi->p->err_refcon,
 355                                         "No entry for vnode %d in directory %d",
 356                                         vnode, parent);
 357                 if (path)
 358                     free(path);
 359                 return ENOENT;
 360             }
 361         }
 362
 363         nl = strlen(name);
 364         if (path) {
 365             path = realloc(path, nl + pl + 2);
 366             if (!path) {
 367                 if (phi->p->cb_error)
 368                     (phi->p->cb_error) (ENOMEM, 1, phi->p->err_refcon,
 369                                         "No memory for pathname of vnode 1");
 370                 return ENOMEM;
 371             }
 372             x = path + pl;
 373             y = x + nl + 1;
 374             while (x >= path)
 375                 *y-- = *x--;
 376             path[0] = '/';
 377             for (x = name, y = path + 1; *x;)
 378                 *y++ = *x++;
 379             pl += nl + 1;
 380         } else {
 381             path = (char *)malloc(nl + 2);
 382             if (!path) {
 383                 if (phi->p->cb_error)
 384                     (phi->p->cb_error) (ENOMEM, 1, phi->p->err_refcon,
 385                                         "No memory for pathname of vnode 1");
 386                 return ENOMEM;
 387             }
 388             path[0] = '/';
 389             strcpy(path + 1, name);
 390             pl = nl + 1;
 391         }
 392         if (!fast)
 393             free(name);
 394         vnode = parent;
 395     }
 396     *his_path = path;
 397     return 0;
 398 }