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