tools: Rename u_int64 to solve AIX problem
[openafs.git] / src / tools / util.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 /* util.c - Useful utilities */
30
31 #include <errno.h>
32
33 #include "xf_errs.h"
34 #include "dumpscan.h"
35 #include "dumpscan_errs.h"
36 #include "dumpfmt.h"
37
38
39 /* Take care of errno, ERROR_XFILE_EOF, and ENOMEM return codes.
40  * Call whatever callbacks are necessary, and return the code to
41  * actually use.  If you don't want '0' to result in a DSERR_TAG,
42  * then you must translate it to DSERR_DONE before calling this.
43  */
44 /*** THIS FUNCTION INTENDED FOR INTERNAL USE ONLY ***/
45 int
46 handle_return(int r, XFILE * X, unsigned char tag, dump_parser * p)
47 {
48     dt_uint64 where, xwhere;
49
50     switch (r) {
51     case 0:
52         if (p->cb_error) {
53             xftell(X, &where);
54             sub64_32(xwhere, where, 1);
55             (p->cb_error) (DSERR_TAG, 1, p->err_refcon,
56                            (tag > 0x20 && tag < 0x7f)
57                            ? "Unexpected tag '%c' at %s = 0x%s" :
58                            "Unexpected tag 0x%02x at %s = 0x%s", tag,
59                            decimate_int64(&xwhere, 0), hexify_int64(&xwhere,
60                                                                     0));
61         }
62         return DSERR_TAG;
63
64     case ERROR_XFILE_EOF:
65         if (p->cb_error) {
66             xftell(X, &where);
67             (p->cb_error) (ERROR_XFILE_EOF, 1, p->err_refcon,
68                            "Unexpected EOF at %s = 0x%s",
69                            decimate_int64(&where, 0), hexify_int64(&where,
70                                                                    0));
71         }
72         return ERROR_XFILE_EOF;
73
74     case ENOMEM:
75         if (p->cb_error) {
76             xftell(X, &where);
77             (p->cb_error) (ENOMEM, 1, p->err_refcon,
78                            "Out of memory at %s = 0x%s",
79                            decimate_int64(&where, 0), hexify_int64(&where,
80                                                                    0));
81         }
82         return ENOMEM;
83
84     case DSERR_DONE:
85         return 0;
86
87     default:
88         /* For other negative valuees, the callback was already done */
89         if (r > 0 && p->cb_error)
90             (p->cb_error) (r, 1, p->err_refcon,
91                            "System error %d reading dump file", r);
92         return r;
93     }
94 }
95
96
97 /* Prepare a tag_parse_info for use by the dump parser. */
98 /* ** THIS FUNCTION INTENDED FOR INTERNAL USE ONLY ** */
99 void
100 prep_pi(dump_parser * p, tag_parse_info * pi)
101 {
102     memset(pi, 0, sizeof(tag_parse_info));
103     pi->err_refcon = p->err_refcon;
104     pi->cb_error = p->cb_error;
105
106     if (p->repair_flags & DSFIX_SKIP)
107         pi->flags |= TPFLAG_SKIP;
108     if ((p->flags & DSFLAG_SEEK) && (p->repair_flags & DSFIX_RSKIP))
109         pi->flags |= TPFLAG_RSKIP;
110 }
111
112
113 /* Does the designated location match a vnode?
114  * Returns 0 if yes, DSERR_FMT if no, something else on error
115  */
116 /*** THIS FUNCTION INTENDED FOR INTERNAL USE ONLY ***/
117 int
118 match_next_vnode(XFILE * X, dump_parser * p, dt_uint64 * where,
119                  afs_uint32 vnode)
120 {
121     afs_uint32 r, x, y, z;
122     unsigned char tag;
123
124     if ((r = xfseek(X, where)))
125         return r;
126     if ((r = ReadByte(X, &tag)))
127         return r;
128     switch (tag) {
129     case 3:                     /* A vnode? */
130         if ((r = ReadInt32(X, &x)))
131             return r;
132         if ((r = ReadInt32(X, &y)))
133             return r;
134         if ((r = ReadByte(X, &tag)))
135           return r;
136         if (!((vnode & 1) && !(x & 1) && x < vnode)
137             && !((vnode & 1) == (x & 1) && x > vnode))
138             return DSERR_FMT;
139         if (x > vnode && x - vnode > 10000)
140             return DSERR_FMT;
141         if (y < 0 || y > p->vol_uniquifier)
142             return DSERR_FMT;
143
144         /* Now, what follows the vnode/uniquifier? */
145         switch (tag) {
146         case 3:         /* Another vnode? - Only if this is a non-directory */
147             if (x & 1)
148                 return DSERR_FMT;
149             if ((r = ReadInt32(X, &z)))
150                 return r;
151             if (!((x & 1) && !(z & 1) && z < x)
152                 && !((x & 1) == (z & 1) && z > x))
153                 return DSERR_FMT;
154             return 0;
155
156         case 4:         /* Dump end - Only if this is a non-directory */
157             if (x & 1)
158                 return DSERR_FMT;
159             if ((r = ReadInt32(X, &z)))
160                 return r;
161             if (z != DUMPENDMAGIC)
162                 return DSERR_FMT;
163             return 0;
164
165         case 't':               /* Vnode type byte */
166             if ((r = ReadByte(X, &tag)))
167                 return r;
168             if ((tag == vFile || tag == vSymlink) && !(x & 1))
169                 return 0;
170             if (tag == vDirectory && (x & 1))
171                 return 0;
172             return DSERR_FMT;
173
174         default:
175             return DSERR_FMT;
176         }
177
178     case 4:                     /* A dump end? */
179         if ((r = ReadInt32(X, &x)))
180             return r;
181         if (x != DUMPENDMAGIC)
182             return DSERR_FMT;
183         return 0;
184
185     default:
186         return DSERR_FMT;
187     }
188 }