Don't cast the return from realloc()
[openafs.git] / src / tools / dumpscan / parsevnode.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 /* parsevnode.c - Parse a VNode */
30
31 #include <sys/types.h>
32 #include <netinet/in.h>
33 #include <errno.h>
34
35 #include "dumpscan.h"
36 #include "dumpscan_errs.h"
37 #include "dumpfmt.h"
38 #include "internal.h"
39
40 #include <afs/acl.h>
41 #include <afs/prs_fs.h>
42
43 static afs_uint32 LastGoodVNode = 0;
44 static afs_uint32 store_vnode(XFILE *, unsigned char *, tagged_field *,
45                               afs_uint32, tag_parse_info *, void *, void *);
46 static afs_uint32 parse_acl(XFILE *, unsigned char *, tagged_field *,
47                             afs_uint32, tag_parse_info *, void *, void *);
48 static afs_uint32 parse_vdata(XFILE *, unsigned char *, tagged_field *,
49                               afs_uint32, tag_parse_info *, void *, void *);
50
51 /** Field list for vnodes **/
52 static tagged_field vnode_fields[] = {
53     {VTAG_TYPE, DKIND_BYTE, " VNode type:   ", store_vnode, 0, 0},
54     {VTAG_NLINKS, DKIND_INT16, " Link count:   ", store_vnode, 0, 0},
55     {VTAG_DVERS, DKIND_INT32, " Version:      ", store_vnode, 0, 0},
56     {VTAG_CLIENT_DATE, DKIND_TIME, " Server Date:  ", store_vnode, 0, 0},
57     {VTAG_AUTHOR, DKIND_INT32, " Author:       ", store_vnode, 0, 0},
58     {VTAG_OWNER, DKIND_INT32, " Owner:        ", store_vnode, 0, 0},
59     {VTAG_GROUP, DKIND_INT32, " Group:        ", store_vnode, 0, 0},
60     {VTAG_MODE, DKIND_INT16, " UNIX mode:    ", store_vnode, 0, 0},
61     {VTAG_PARENT, DKIND_INT32, " Parent:       ", store_vnode, 0, 0},
62     {VTAG_SERVER_DATE, DKIND_TIME, " Client Date:  ", store_vnode, 0, 0},
63     {VTAG_ACL, DKIND_SPECIAL, " xxxxxxxx ACL: ", parse_acl, 0, 0},
64     {VTAG_DATA, DKIND_SPECIAL, " Contents:     ", parse_vdata, 0, 0},
65     {0, 0, 0, 0, 0, 0}
66 };
67
68
69 static afs_uint32
70 resync_vnode(XFILE * X, dump_parser * p, afs_vnode * v, int start, int limit)
71 {
72     dt_uint64 where, expected_where;
73     afs_uint32 r;
74     int i;
75
76     if ((r = xftell(X, &expected_where)))
77         return r;
78     cp64(where, expected_where);
79
80     r = match_next_vnode(X, p, &where, v->vnode);
81     if (r && r != DSERR_FMT)
82         return r;
83     if (r)
84         for (i = -start; i < limit; i++) {
85             add64_32(where, expected_where, i);
86             r = match_next_vnode(X, p, &where, v->vnode);
87             if (!r)
88                 break;
89             if (r != DSERR_FMT)
90                 return r;
91         }
92     if (r) {
93         if (p->cb_error)
94             (p->cb_error) (r, 1, p->err_refcon,
95                            "Unable to resync after vnode %d [%s = 0x%s]",
96                            v->vnode, decimate_int64(&expected_where, 0),
97                            hexify_int64(&expected_where, 0));
98         return r;
99     }
100     if (ne64(where, expected_where) && p->cb_error) {
101         (p->cb_error) (DSERR_FMT, 0, p->err_refcon,
102                        "Vnode after %d not in expected location", v->vnode);
103         (p->cb_error) (DSERR_FMT, 0, p->err_refcon,
104                        "Expected location: %s = 0x%s",
105                        decimate_int64(&expected_where, 0),
106                        hexify_int64(&expected_where, 0));
107         (p->cb_error) (DSERR_FMT, 0, p->err_refcon,
108                        "Actual location: %s = 0x%s", decimate_int64(&where,
109                                                                     0),
110                        hexify_int64(&where, 0));
111     }
112     return xfseek(X, &where);
113 }
114
115
116 /* Parse a VNode, including any tagged attributes and data, and call the
117  * appropriate callback, if one is defined.
118  */
119 afs_uint32
120 parse_vnode(XFILE * X, unsigned char *tag, tagged_field * field,
121             afs_uint32 value, tag_parse_info * pi, void *g_refcon,
122             void *l_refcon)
123 {
124     dump_parser *p = (dump_parser *) g_refcon;
125     afs_uint32(*cb) (afs_vnode *, XFILE *, void *);
126     dt_uint64 where, offset2k;
127     afs_vnode v;
128     afs_uint32 r;
129
130
131     if ((r = xftell(X, &where)))
132         return r;
133     memset(&v, 0, sizeof(v));
134     sub64_32(v.offset, where, 1);
135     if ((r = ReadInt32(X, &v.vnode)))
136         return r;
137     if ((r = ReadInt32(X, &v.vuniq)))
138         return r;
139
140     mk64(offset2k, 0, 2048);
141     if (!LastGoodVNode
142         || ((p->flags & DSFLAG_SEEK) && v.vnode == 1
143             && lt64(v.offset, offset2k)))
144         LastGoodVNode = -1;
145
146     if (p->print_flags & DSPRINT_ITEM) {
147         printf("%s %d/%d [%s = 0x%s]\n", field->label, v.vnode, v.vuniq,
148                decimate_int64(&where, 0), hexify_int64(&where, 0));
149     }
150
151     r = ParseTaggedData(X, vnode_fields, tag, pi, g_refcon, (void *)&v);
152
153     /* Try to resync, if requested */
154     if (!r && (p->repair_flags & DSFIX_VFSYNC)) {
155         afs_uint32 drop;
156         dt_uint64 xwhere;
157
158         if ((r = xftell(X, &where)))
159             return r;
160         sub64_32(xwhere, where, 1);
161
162         /* Are we at the start of a valid vnode (or dump end)? */
163         r = match_next_vnode(X, p, &xwhere, v.vnode);
164         if (r && r != DSERR_FMT)
165             return r;
166         if (r) {                /* Nope. */
167             /* Was _this_ a valid vnode?  If so, we can keep it and search for
168              * the next one.  Otherwise, we throw it out, and start the search
169              * at the starting point of this vnode.
170              */
171             drop = r = match_next_vnode(X, p, &v.offset, LastGoodVNode);
172             if (r && r != DSERR_FMT)
173                 return r;
174             if (!r) {
175                 add64_32(where, v.offset, 1);
176                 if ((r = xfseek(X, &v.offset)))
177                     return r;
178             } else {
179                 if ((r = xfseek(X, &xwhere)))
180                     return r;
181             }
182             if ((r = resync_vnode(X, p, &v, 0, 1024)))
183                 return r;
184             if ((r = ReadByte(X, tag)))
185                 return r;
186             if (drop) {
187                 if (p->cb_error)
188                     (p->cb_error) (DSERR_FMT, 0, p->err_refcon,
189                                    "Dropping vnode %d", v.vnode);
190                 return 0;
191             }
192         } else {
193             if ((r = xfseek(X, &where)))
194                 return r;
195         }
196     }
197     LastGoodVNode = v.vnode;
198
199     if (!r) {
200         if (v.field_mask & F_VNODE_TYPE)
201             switch (v.type) {
202             case vFile:
203                 cb = p->cb_vnode_file;
204                 break;
205             case vDirectory:
206                 cb = p->cb_vnode_dir;
207                 break;
208             case vSymlink:
209                 cb = p->cb_vnode_link;
210                 break;
211             default:
212                 cb = p->cb_vnode_wierd;
213                 break;
214         } else
215             cb = p->cb_vnode_empty;
216         if (cb) {
217             dt_uint64 where;
218
219             if ((r = xftell(X, &where)))
220                 return r;
221             r = (cb) (&v, X, p->refcon);
222             if (p->flags & DSFLAG_SEEK) {
223                 if (!r)
224                     r = xfseek(X, &where);
225                 else
226                     xfseek(X, &where);
227             }
228         }
229     }
230     return r;
231 }
232
233
234 /* Store data in a vnode */
235 static afs_uint32
236 store_vnode(XFILE * X, unsigned char *tag, tagged_field * field,
237             afs_uint32 value, tag_parse_info * pi, void *g_refcon,
238             void *l_refcon)
239 {
240     dump_parser *p = (dump_parser *) g_refcon;
241     afs_vnode *v = (afs_vnode *) l_refcon;
242     time_t when;
243     afs_uint32 r = 0;
244
245     switch (field->tag) {
246     case VTAG_TYPE:
247         v->field_mask |= F_VNODE_TYPE;
248         v->type = value;
249         if (p->print_flags & DSPRINT_VNODE) {
250             switch (value) {
251             case vFile:
252                 printf("%sFile (%d)\n", field->label, value);
253                 break;
254             case vDirectory:
255                 printf("%sDirectory (%d)\n", field->label, value);
256                 break;
257             case vSymlink:
258                 printf("%sSymbolic Link (%d)\n", field->label, value);
259                 break;
260             default:
261                 printf("%s??? (%d)\n", field->label, value);
262             }
263             return r;
264         }
265         break;
266
267     case VTAG_NLINKS:
268         v->field_mask |= F_VNODE_NLINKS;
269         v->nlinks = value;
270         break;
271
272     case VTAG_DVERS:
273         v->field_mask |= F_VNODE_DVERS;
274         v->datavers = value;
275         break;
276
277     case VTAG_CLIENT_DATE:
278         v->field_mask |= F_VNODE_CDATE;
279         v->client_date = value;
280         break;
281
282     case VTAG_SERVER_DATE:
283         v->field_mask |= F_VNODE_SDATE;
284         v->server_date = value;
285         break;
286
287     case VTAG_AUTHOR:
288         v->field_mask |= F_VNODE_AUTHOR;
289         v->author = value;
290         break;
291
292     case VTAG_OWNER:
293         v->field_mask |= F_VNODE_OWNER;
294         v->owner = value;
295         break;
296
297     case VTAG_GROUP:
298         v->field_mask |= F_VNODE_GROUP;
299         v->group = value;
300         break;
301
302     case VTAG_MODE:
303         v->field_mask |= F_VNODE_MODE;
304         v->mode = value;
305         break;
306
307     case VTAG_PARENT:
308         v->field_mask |= F_VNODE_PARENT;
309         v->parent = value;
310         break;
311     }
312
313     if (p->print_flags & DSPRINT_VNODE)
314         switch (field->kind) {
315         case DKIND_BYTE:
316         case DKIND_INT16:
317         case DKIND_INT32:
318             printf("%s%d\n", field->label, value);
319             break;
320         case DKIND_HEX8:
321             printf("%s0x%02x\n", field->label, value);
322             break;
323         case DKIND_HEX16:
324             printf("%s0x%04x\n", field->label, value);
325             break;
326         case DKIND_HEX32:
327             printf("%s0x%08x\n", field->label, value);
328             break;
329         case DKIND_CHAR:
330             printf("%s%c\n", field->label, value);
331             break;
332         case DKIND_STRING:
333             printf("%s%s\n", field->label, tag);
334             break;
335         case DKIND_FLAG:
336             printf("%s%s\n", field->label, value ? "true" : "false");
337             break;
338         case DKIND_TIME:
339             when = value;
340             printf("%s%s", field->label, ctime(&when));
341             break;
342         }
343     return r;
344 }
345
346
347 static char *
348 rights2str(afs_uint32 rights)
349 {
350     static char str[16];
351     char *p = str;
352
353     if (rights & PRSFS_READ)
354         *p++ = 'r';
355     if (rights & PRSFS_LOOKUP)
356         *p++ = 'l';
357     if (rights & PRSFS_INSERT)
358         *p++ = 'i';
359     if (rights & PRSFS_DELETE)
360         *p++ = 'd';
361     if (rights & PRSFS_WRITE)
362         *p++ = 'w';
363     if (rights & PRSFS_LOCK)
364         *p++ = 'k';
365     if (rights & PRSFS_ADMINISTER)
366         *p++ = 'a';
367     if (rights & PRSFS_USR0)
368         *p++ = 'A';
369     if (rights & PRSFS_USR1)
370         *p++ = 'B';
371     if (rights & PRSFS_USR2)
372         *p++ = 'C';
373     if (rights & PRSFS_USR3)
374         *p++ = 'D';
375     if (rights & PRSFS_USR4)
376         *p++ = 'E';
377     if (rights & PRSFS_USR5)
378         *p++ = 'F';
379     if (rights & PRSFS_USR6)
380         *p++ = 'G';
381     if (rights & PRSFS_USR7)
382         *p++ = 'H';
383
384     *p = 0;
385     if (!str[0])
386         strcpy(str, "none");
387     return str;
388 }
389
390
391 /* Parse and store the ACL data from a directory vnode */
392 static afs_uint32
393 parse_acl(XFILE * X, unsigned char *tag, tagged_field * field,
394           afs_uint32 value, tag_parse_info * pi, void *g_refcon,
395           void *l_refcon)
396 {
397     struct acl_accessList *acl;
398     dump_parser *p = (dump_parser *) g_refcon;
399     afs_vnode *v = (afs_vnode *) l_refcon;
400     afs_uint32 r, i, n;
401
402     if ((r = xfread(X, v->acl, SIZEOF_LARGEDISKVNODE - SIZEOF_SMALLDISKVNODE)))
403         return r;
404
405     v->field_mask |= F_VNODE_ACL;
406     if (p->print_flags & DSPRINT_ACL) {
407         acl = (struct acl_accessList *)(v->acl);
408         n = ntohl(acl->positive);
409         if (n) {
410             printf(" Positive ACL: %d entries\n", n);
411             for (i = 0; i < n; i++)
412                 printf("              %9d  %s\n", ntohl(acl->entries[i].id),
413                        rights2str(ntohl(acl->entries[i].rights)));
414         }
415         n = ntohl(acl->negative);
416         if (n) {
417             printf(" Negative ACL: %d entries\n", n);
418             for (i = ntohl(acl->positive); i < ntohl(acl->total); i++)
419                 printf("              %9d  %s\n", ntohl(acl->entries[i].id),
420                        rights2str(ntohl(acl->entries[i].rights)));
421         }
422     }
423     return ReadByte(X, tag);
424 }
425
426
427 /* Parse or skip over the vnode data */
428 static afs_uint32
429 parse_vdata(XFILE * X, unsigned char *tag, tagged_field * field,
430             afs_uint32 value, tag_parse_info * pi, void *g_refcon,
431             void *l_refcon)
432 {
433     dump_parser *p = (dump_parser *) g_refcon;
434     afs_vnode *v = (afs_vnode *) l_refcon;
435     static char *symlink_buf = 0;
436     static int symlink_size = 0;
437     afs_uint32 r;
438
439     if ((r = ReadInt32(X, &v->size)))
440         return r;
441     v->field_mask |= F_VNODE_SIZE;
442
443     if (v->size) {
444         v->field_mask |= F_VNODE_DATA;
445         if ((r = xftell(X, &v->d_offset)))
446             return r;
447         if (p->print_flags & DSPRINT_VNODE)
448             printf("%s%d (0x%08x) bytes at %s (0x%s)\n", field->label,
449                    v->size, v->size, decimate_int64(&v->d_offset, 0),
450                    hexify_int64(&v->d_offset, 0));
451
452         switch (v->type) {
453         case vSymlink:
454             if (v->size > symlink_size) {
455                 if (symlink_buf)
456                     symlink_buf = realloc(symlink_buf, v->size + 1);
457                 else
458                     symlink_buf = (char *)malloc(v->size + 1);
459                 symlink_size = symlink_buf ? v->size : 0;
460             }
461             if (symlink_buf) {
462                 if ((r = xfread(X, symlink_buf, v->size)))
463                     return r;
464                 symlink_buf[v->size] = 0;
465                 if (p->print_flags & DSPRINT_VNODE)
466                     printf(" Target:       %s\n", symlink_buf);
467             } else {
468                 /* Call the callback here, because it's non-fatal */
469                 if (p->cb_error)
470                     (p->cb_error) (ENOMEM, 0, p->err_refcon,
471                                    "Out of memory reading symlink");
472                 if ((r = xfskip(X, v->size)))
473                     return r;
474             }
475             break;
476
477         case vDirectory:
478             if (p->cb_dirent || (p->print_flags & DSPRINT_DIR)) {
479                 if ((r = parse_directory(X, p, v, v->size, 0)))
480                     return r;
481                 break;
482             }
483
484         default:
485             if ((r = xfskip(X, v->size)))
486                 return r;
487         }
488     } else if (p->print_flags & DSPRINT_VNODE) {
489         printf("%sEmpty\n", field->label);
490     }
491     if (p->repair_flags & DSFIX_VDSYNC) {
492         r = resync_vnode(X, p, v, 10, 15);
493         if (r)
494             return r;
495     }
496     return ReadByte(X, tag);
497 }