test-suite-pull-tools-directly-in-20020114
[openafs.git] / src / tests / dump.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 /* dump.c - Write out parts of a volume dump */
30
31 #include "dumpscan.h"
32 #include "dumpfmt.h"
33
34 #define COPYBUFSIZE 65536
35
36 afs_uint32 DumpDumpHeader(XFILE *OX, afs_dump_header *hdr)
37 {
38   afs_uint32 r;
39
40   if (r = WriteTagInt32Pair(OX, TAG_DUMPHEADER, hdr->magic, hdr->version))
41     return r;
42
43   if (hdr->field_mask & F_DUMPHDR_VOLID) {
44     if (r = WriteTagInt32(OX, DHTAG_VOLID, hdr->volid)) return r;
45   }
46   if (hdr->field_mask & F_DUMPHDR_VOLNAME) {
47     if (r = WriteByte(OX, DHTAG_VOLNAME)) return r;
48     if (r = WriteString(OX, hdr->volname)) return r;
49   }
50   if (hdr->field_mask & (F_DUMPHDR_FROM | F_DUMPHDR_TO)) {
51     if (r = WriteTagInt16(OX, DHTAG_DUMPTIMES, 2))
52       return r;
53     if (r = WriteInt32(OX, (hdr->field_mask & F_DUMPHDR_FROM)
54                        ? hdr->from_date : 0))
55       return r;
56     if (r = WriteInt32(OX, (hdr->field_mask & F_DUMPHDR_TO)
57                        ? hdr->to_date : time(0)))
58       return r;
59   }
60   return 0;
61 }
62
63
64 afs_uint32 DumpVolumeHeader(XFILE *OX, afs_vol_header *hdr)
65 {
66   afs_uint32 r;
67   int i;
68
69   if (r = WriteByte(OX, TAG_VOLHEADER)) return r;
70
71   if (hdr->field_mask & F_VOLHDR_VOLID) {
72     if (r = WriteTagInt32(OX, VHTAG_VOLID, hdr->volid)) return r;
73   }
74   if (hdr->field_mask & F_VOLHDR_VOLVERS) {
75     if (r = WriteTagInt32(OX, VHTAG_VERS, hdr->volvers)) return r;
76   }
77   if (hdr->field_mask & F_VOLHDR_VOLNAME) {
78     if (r = WriteByte(OX, VHTAG_VOLNAME)) return r;
79     if (r = WriteString(OX, hdr->volname)) return r;
80   }
81   if (hdr->field_mask & F_VOLHDR_INSERV) {
82     if (r = WriteTagByte(OX, VHTAG_INSERV, hdr->flag_inservice)) return r;
83   }
84   if (hdr->field_mask & F_VOLHDR_BLESSED) {
85     if (r = WriteTagByte(OX, VHTAG_BLESSED, hdr->flag_blessed)) return r;
86   }
87   if (hdr->field_mask & F_VOLHDR_VOLUNIQ) {
88     if (r = WriteTagInt32(OX, VHTAG_VUNIQ, hdr->voluniq)) return r;
89   }
90   if (hdr->field_mask & F_VOLHDR_VOLTYPE) {
91     if (r = WriteTagByte(OX, VHTAG_TYPE, hdr->voltype)) return r;
92   }
93   if (hdr->field_mask & F_VOLHDR_PARENT) {
94     if (r = WriteTagInt32(OX, VHTAG_PARENT, hdr->parent_volid)) return r;
95   }
96   if (hdr->field_mask & F_VOLHDR_CLONE) {
97     if (r = WriteTagInt32(OX, VHTAG_CLONE, hdr->clone_volid)) return r;
98   }
99   if (hdr->field_mask & F_VOLHDR_MAXQ) {
100     if (r = WriteTagInt32(OX, VHTAG_MAXQUOTA, hdr->maxquota)) return r;
101   }
102   if (hdr->field_mask & F_VOLHDR_MINQ) {
103     if (r = WriteTagInt32(OX, VHTAG_MINQUOTA, hdr->minquota)) return r;
104   }
105   if (hdr->field_mask & F_VOLHDR_DISKUSED) {
106     if (r = WriteTagInt32(OX, VHTAG_DISKUSED, hdr->diskused)) return r;
107   }
108   if (hdr->field_mask & F_VOLHDR_NFILES) {
109     if (r = WriteTagInt32(OX, VHTAG_FILECNT, hdr->nfiles)) return r;
110   }
111   if (hdr->field_mask & F_VOLHDR_ACCOUNT) {
112     if (r = WriteTagInt32(OX, VHTAG_ACCOUNT, hdr->account_no)) return r;
113   }
114   if (hdr->field_mask & F_VOLHDR_OWNER) {
115     if (r = WriteTagInt32(OX, VHTAG_OWNER, hdr->owner)) return r;
116   }
117   if (hdr->field_mask & F_VOLHDR_CREATE_DATE) {
118     if (r = WriteTagInt32(OX, VHTAG_CREAT, hdr->create_date)) return r;
119   }
120   if (hdr->field_mask & F_VOLHDR_ACCESS_DATE) {
121     if (r = WriteTagInt32(OX, VHTAG_ACCESS, hdr->access_date)) return r;
122   }
123   if (hdr->field_mask & F_VOLHDR_UPDATE_DATE) {
124     if (r = WriteTagInt32(OX, VHTAG_UPDATE, hdr->update_date)) return r;
125   }
126   if (hdr->field_mask & F_VOLHDR_EXPIRE_DATE) {
127     if (r = WriteTagInt32(OX, VHTAG_EXPIRE, hdr->expire_date)) return r;
128   }
129   if (hdr->field_mask & F_VOLHDR_BACKUP_DATE) {
130     if (r = WriteTagInt32(OX, VHTAG_BACKUP, hdr->backup_date)) return r;
131   }
132   if (hdr->field_mask & F_VOLHDR_OFFLINE_MSG) {
133     if (r = WriteTagInt32(OX, VHTAG_OFFLINE, hdr->offline_msg)) return r;
134   }
135   if (hdr->field_mask & F_VOLHDR_MOTD) {
136     if (r = WriteTagInt32(OX, VHTAG_MOTD, hdr->motd_msg)) return r;
137   }
138   if (hdr->field_mask & F_VOLHDR_WEEKUSE) {
139     if (r = WriteTagInt16(OX, VHTAG_WEEKUSE, 7)) return r;
140     for (i = 0; i < 7; i++)
141       if (r = WriteInt32(OX, hdr->weekuse[i])) return r;
142   }
143   if (hdr->field_mask & F_VOLHDR_DAYUSE_DATE) {
144     if (r = WriteTagInt32(OX, VHTAG_DUDATE, hdr->dayuse_date)) return r;
145   }
146   if (hdr->field_mask & F_VOLHDR_DAYUSE) {
147     if (r = WriteTagInt32(OX, VHTAG_DAYUSE, hdr->dayuse)) return r;
148   }
149   return 0;
150 }
151
152
153 afs_uint32 DumpVNode(XFILE *OX, afs_vnode *v)
154 {
155   afs_uint32 r;
156
157   if (r = WriteTagInt32Pair(OX, TAG_VNODE, v->vnode, v->vuniq)) return r;
158
159   if (v->field_mask & F_VNODE_TYPE) {
160     if (r = WriteTagByte(OX, VTAG_TYPE, v->type)) return r;
161   }
162   if (v->field_mask & F_VNODE_NLINKS) {
163     if (r = WriteTagInt16(OX, VTAG_NLINKS, v->nlinks)) return r;
164   }
165   if (v->field_mask & F_VNODE_DVERS) {
166     if (r = WriteTagInt32(OX, VTAG_DVERS, v->datavers)) return r;
167   }
168   if (v->field_mask & F_VNODE_SDATE) {
169     if (r = WriteTagInt32(OX, VTAG_SERVER_DATE, v->server_date)) return r;
170   }
171   if (v->field_mask & F_VNODE_AUTHOR) {
172     if (r = WriteTagInt32(OX, VTAG_AUTHOR, v->author)) return r;
173   }
174   if (v->field_mask & F_VNODE_OWNER) {
175     if (r = WriteTagInt32(OX, VTAG_OWNER, v->owner)) return r;
176   }
177   if (v->field_mask & F_VNODE_GROUP) {
178     if (r = WriteTagInt32(OX, VTAG_GROUP, v->group)) return r;
179   }
180   if (v->field_mask & F_VNODE_MODE) {
181     if (r = WriteTagInt16(OX, VTAG_MODE, v->mode)) return r;
182   }
183   if (v->field_mask & F_VNODE_PARENT) {
184     if (r = WriteTagInt32(OX, VTAG_PARENT, v->parent)) return r;
185   }
186   if (v->field_mask & F_VNODE_CDATE) {
187     if (r = WriteTagInt32(OX, VTAG_CLIENT_DATE, v->client_date)) return r;
188   }
189   if (v->field_mask & F_VNODE_ACL) {
190     if (r = WriteByte(OX, VTAG_ACL)) return r;
191     if (r = xfwrite(OX, v->acl, SIZEOF_LARGEDISKVNODE - SIZEOF_SMALLDISKVNODE))
192       return r;
193   }
194   return 0;
195 }
196
197
198 afs_uint32 DumpVNodeData(XFILE *OX, char *buf, afs_uint32 size)
199 {
200   afs_uint32 r;
201
202   if (r = WriteTagInt32(OX, VTAG_DATA, size)) return r;
203   if (r = xfwrite(OX, buf, size)) return r;
204   return 0;
205 }
206
207
208 afs_uint32 CopyVNodeData(XFILE *OX, XFILE *X, afs_uint32 size)
209 {
210   afs_uint32 r, n;
211   static char buf[COPYBUFSIZE];
212
213   if (r = WriteTagInt32(OX, VTAG_DATA, size)) return r;
214   while (size) {
215     n = (size > COPYBUFSIZE) ? COPYBUFSIZE : size;
216     if (r = xfread(X, buf, n)) return r;
217     if (r = xfwrite(OX, buf, n)) return r;
218     size -= n;
219   }
220   return 0;
221 }
222
223
224 afs_uint32 DumpDumpEnd(XFILE *OX) {
225   afs_uint32 r;
226
227   if (r = WriteTagInt32(OX, TAG_DUMPEND, DUMPENDMAGIC)) return r;
228   return 0;
229 }