test-suite-pull-tools-directly-in-20020114
[openafs.git] / src / tests / parsevol.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 /* parsevol.c - Parse a volume header */
30
31 #include "dumpscan.h"
32 #include "dumpscan_errs.h"
33 #include "dumpfmt.h"
34
35 static afs_uint32 store_volhdr   (XFILE *, unsigned char *, tagged_field *,
36                                afs_uint32, tag_parse_info *, void *, void *);
37 static afs_uint32 parse_weekuse  (XFILE *, unsigned char *, tagged_field *,
38                                afs_uint32, tag_parse_info *, void *, void *);
39
40 /** Field list for volume headers **/
41 static tagged_field volhdr_fields[] = {
42   { VHTAG_VOLID,     DKIND_INT32,   " Volume ID:   ", store_volhdr,  0, 0 },
43   { VHTAG_VERS,      DKIND_INT32,   " Version:     ", store_volhdr,  0, 0 },
44   { VHTAG_VOLNAME,   DKIND_STRING,  " Volume name: ", store_volhdr,  0, 0 },
45   { VHTAG_INSERV,    DKIND_FLAG,    " In service?  ", store_volhdr,  0, 0 },
46   { VHTAG_BLESSED,   DKIND_FLAG,    " Blessed?     ", store_volhdr,  0, 0 },
47   { VHTAG_VUNIQ,     DKIND_INT32,   " Uniquifier:  ", store_volhdr,  0, 0 },
48   { VHTAG_TYPE,      DKIND_BYTE,    " Type:        ", store_volhdr,  0, 0 },
49   { VHTAG_PARENT,    DKIND_INT32,   " Parent ID:   ", store_volhdr,  0, 0 },
50   { VHTAG_CLONE,     DKIND_INT32,   " Clone ID:    ", store_volhdr,  0, 0 },
51   { VHTAG_MAXQUOTA,  DKIND_INT32,   " Max quota:   ", store_volhdr,  0, 0 },
52   { VHTAG_MINQUOTA,  DKIND_INT32,   " Min quota:   ", store_volhdr,  0, 0 },
53   { VHTAG_DISKUSED,  DKIND_INT32,   " Disk used:   ", store_volhdr,  0, 0 },
54   { VHTAG_FILECNT,   DKIND_INT32,   " File count:  ", store_volhdr,  0, 0 },
55   { VHTAG_ACCOUNT,   DKIND_INT32,   " Account:     ", store_volhdr,  0, 0 },
56   { VHTAG_OWNER,     DKIND_INT32,   " Owner:       ", store_volhdr,  0, 0 },
57   { VHTAG_CREAT,     DKIND_TIME,    " Created:     ", store_volhdr,  0, 0 },
58   { VHTAG_ACCESS,    DKIND_TIME,    " Accessed:    ", store_volhdr,  0, 0 },
59   { VHTAG_UPDATE,    DKIND_TIME,    " Updated:     ", store_volhdr,  0, 0 },
60   { VHTAG_EXPIRE,    DKIND_TIME,    " Expires:     ", store_volhdr,  0, 0 },
61   { VHTAG_BACKUP,    DKIND_TIME,    " Backed up:   ", store_volhdr,  0, 0 },
62   { VHTAG_OFFLINE,   DKIND_STRING,  " Offine Msg:  ", store_volhdr,  0, 0 },
63   { VHTAG_MOTD,      DKIND_STRING,  " MOTD:        ", store_volhdr,  0, 0 },
64   { VHTAG_WEEKUSE,   DKIND_SPECIAL, " Weekuse:     ", parse_weekuse, 0, 0 },
65   { VHTAG_DUDATE,    DKIND_TIME,    " Dayuse Date: ", store_volhdr,  0, 0 },
66   { VHTAG_DAYUSE,    DKIND_INT32,   " Daily usage: ", store_volhdr,  0, 0 },
67   { 0,0,0,0,0,0 }};
68
69
70 /* Parse a volume header, including any tagged attributes, and call the
71  * volume-header callback, if one is defined.
72  */
73 afs_uint32 parse_volhdr(XFILE *X, unsigned char *tag, tagged_field *field,
74                      afs_uint32 value, tag_parse_info *pi,
75                      void *g_refcon, void *l_refcon)
76 {
77   dump_parser *p = (dump_parser *)g_refcon;
78   afs_vol_header hdr;
79   u_int64 where;
80   afs_uint32 r;
81
82   memset(&hdr, 0, sizeof(hdr));
83   if (r = xftell(X, &where)) return r;
84   sub64_32(hdr.offset, where, 1);
85   if (p->print_flags & DSPRINT_VOLHDR)
86     printf("%s [%s = 0x%s]\n", field->label,
87            decimate_int64(&hdr.offset, 0), hexify_int64(&hdr.offset, 0));
88
89   r = ParseTaggedData(X, volhdr_fields, tag, pi, g_refcon, (void *)&hdr);
90
91   if (!r && p->cb_volhdr) {
92     if (r = xftell(X, &where)) return r;
93     r = (p->cb_volhdr)(&hdr, X, p->refcon);
94     if (p->flags & DSFLAG_SEEK) {
95       if (!r) r = xfseek(X, &where);
96       else xfseek(X, &where);
97     }
98   }
99   if (hdr.field_mask & F_VOLHDR_VOLUNIQ)
100     p->vol_uniquifier = hdr.voluniq;
101   if (hdr.field_mask & F_VOLHDR_VOLNAME)
102     free(hdr.volname);
103   if (hdr.field_mask & F_VOLHDR_OFFLINE_MSG)
104     free(hdr.offline_msg);
105   if (hdr.field_mask & F_VOLHDR_MOTD)
106     free(hdr.motd_msg);
107   return r;
108 }
109
110
111 /* Store data in a volume header */
112 static afs_uint32 store_volhdr(XFILE *X, unsigned char *tag, tagged_field *field,
113                             afs_uint32 value, tag_parse_info *pi,
114                             void *g_refcon, void *l_refcon)
115 {
116   dump_parser *p = (dump_parser *)g_refcon;
117   afs_vol_header *hdr = (afs_vol_header *)l_refcon;
118   time_t when;
119   afs_uint32 r = 0;
120
121   switch (field->tag) {
122   case VHTAG_VOLID:
123     hdr->field_mask |= F_VOLHDR_VOLID;
124     hdr->volid = value;
125     break;
126
127   case VHTAG_VERS:
128     hdr->field_mask |= F_VOLHDR_VOLVERS;
129     hdr->volvers = value;
130     break;
131
132   case VHTAG_VOLNAME:
133     if (tag && tag[0]) {
134       hdr->field_mask |= F_VOLHDR_VOLNAME;
135       hdr->volname = tag;
136       r = DSERR_KEEP;
137     }
138     break;
139
140   case VHTAG_INSERV:
141     hdr->field_mask |= F_VOLHDR_INSERV;
142     hdr->flag_inservice = value;
143     break;
144
145   case VHTAG_BLESSED:
146     hdr->field_mask |= F_VOLHDR_BLESSED;
147     hdr->flag_blessed = value;
148     break;
149
150   case VHTAG_VUNIQ:
151     hdr->field_mask |= F_VOLHDR_VOLUNIQ;
152     hdr->voluniq = value;
153     break;
154
155   case VHTAG_TYPE:
156     hdr->field_mask |= F_VOLHDR_VOLTYPE;
157     hdr->voltype = value;
158     break;
159
160   case VHTAG_PARENT:
161     hdr->field_mask |= F_VOLHDR_PARENT;
162     hdr->parent_volid = value;
163     break;
164
165   case VHTAG_CLONE:
166     hdr->field_mask |= F_VOLHDR_CLONE;
167     hdr->clone_volid = value;
168     break;
169
170   case VHTAG_MAXQUOTA:
171     hdr->field_mask |= F_VOLHDR_MAXQ;
172     hdr->maxquota = value;
173     break;
174
175   case VHTAG_MINQUOTA:
176     hdr->field_mask |= F_VOLHDR_MINQ;
177     hdr->minquota = value;
178     break;
179
180   case VHTAG_DISKUSED:
181     hdr->field_mask |= F_VOLHDR_DISKUSED;
182     hdr->diskused = value;
183     break;
184
185   case VHTAG_FILECNT:
186     hdr->field_mask |= F_VOLHDR_NFILES;
187     hdr->nfiles = value;
188     break;
189
190   case VHTAG_ACCOUNT:
191     hdr->field_mask |= F_VOLHDR_ACCOUNT;
192     hdr->account_no = value;
193     break;
194
195   case VHTAG_OWNER:
196     hdr->field_mask |= F_VOLHDR_OWNER;
197     hdr->owner = value;
198     break;
199
200   case VHTAG_CREAT:
201     hdr->field_mask |= F_VOLHDR_CREATE_DATE;
202     hdr->create_date = value;
203     break;
204
205   case VHTAG_ACCESS:
206     hdr->field_mask |= F_VOLHDR_ACCESS_DATE;
207     hdr->access_date = value;
208     break;
209
210   case VHTAG_UPDATE:
211     hdr->field_mask |= F_VOLHDR_UPDATE_DATE;
212     hdr->update_date = value;
213     break;
214
215   case VHTAG_EXPIRE:
216     hdr->field_mask |= F_VOLHDR_EXPIRE_DATE;
217     hdr->expire_date = value;
218     break;
219
220   case VHTAG_BACKUP:
221     hdr->field_mask |= F_VOLHDR_BACKUP_DATE;
222     hdr->backup_date = value;
223     break;
224
225   case VHTAG_OFFLINE:
226     if (tag && tag[0]) {
227       hdr->field_mask |= F_VOLHDR_OFFLINE_MSG;
228       hdr->offline_msg = tag;
229       r = DSERR_KEEP;
230     }
231     break;
232
233   case VHTAG_MOTD:
234     if (tag && tag[0]) {
235       hdr->field_mask |= F_VOLHDR_MOTD;
236       hdr->motd_msg = tag;
237       r = DSERR_KEEP;
238     }
239     break;
240
241   case VHTAG_DUDATE:
242     hdr->field_mask |= F_VOLHDR_DAYUSE_DATE;
243     hdr->dayuse_date = value;
244     break;
245
246   case VHTAG_DAYUSE:
247     hdr->field_mask |= F_VOLHDR_DAYUSE;
248     hdr->dayuse = value;
249     break;
250   }
251
252   if (p->print_flags & DSPRINT_VOLHDR)
253     switch (field->kind) {
254     case DKIND_BYTE:
255     case DKIND_INT16:
256     case DKIND_INT32:  printf("%s%d\n",     field->label, value); break;
257     case DKIND_HEX8:   printf("%s0x%02x\n", field->label, value); break;
258     case DKIND_HEX16:  printf("%s0x%04x\n", field->label, value); break;
259     case DKIND_HEX32:  printf("%s0x%08x\n", field->label, value); break;
260     case DKIND_CHAR:   printf("%s%c\n",     field->label, value); break;
261     case DKIND_STRING: printf("%s%s\n",     field->label, tag);   break;
262     case DKIND_FLAG:
263       printf("%s%s\n", field->label, value ? "true" : "false");
264       break;
265     case DKIND_TIME:
266       when = value;
267       printf("%s%s", field->label, ctime(&when));
268       break;
269   }
270   return r;
271 }
272
273
274 /* Parse and store the week use data from a volume header */
275 static afs_uint32 parse_weekuse(XFILE *X, unsigned char *tag, tagged_field *field,
276                              afs_uint32 value, tag_parse_info *pi,
277                              void *g_refcon, void *l_refcon)
278 {
279   dump_parser *p = (dump_parser *)g_refcon;
280   afs_vol_header *hdr = (afs_vol_header *)l_refcon;
281   afs_uint16 count;
282   afs_uint32 r;
283   unsigned int i;
284
285   if (r = ReadInt16(X, &count)) return r;
286   if (count != 7) {
287     if (p->cb_error)
288       (p->cb_error)(DSERR_FMT, 1, p->err_refcon,
289                     "Incorrect array count (%d) in weekuse data", count);
290     return DSERR_FMT;
291   }
292   for (i = 0; i < count; i++)
293     if (r = ReadInt32(X, hdr->weekuse + i)) return r;
294   hdr->field_mask |= F_VOLHDR_WEEKUSE;
295   if (p->print_flags & DSPRINT_VOLHDR) {
296     printf("%s%10d %10d %10d %10d\n", field->label,
297            hdr->weekuse[0], hdr->weekuse[1], hdr->weekuse[2], hdr->weekuse[3]);
298     printf("%s%10d %10d %10d\n", field->label,
299            hdr->weekuse[4], hdr->weekuse[5], hdr->weekuse[6]);
300   }
301   return ReadByte(X, tag);
302 }