git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/record_util.c

   1 /*
   2    Bacula(R) - The Network Backup Solution
   3
   4    Copyright (C) 2000-2017 Kern Sibbald
   5
   6    The original author of Bacula is Kern Sibbald, with contributions
   7    from many others, a complete list can be found in the file AUTHORS.
   8
   9    You may use this file and others of this release according to the
  10    license defined in the LICENSE file, which includes the Affero General
  11    Public License, v3.0 ("AGPLv3") and some additional permissions and
  12    terms pursuant to its AGPLv3 Section 7.
  13
  14    This notice must be preserved when any source code is
  15    conveyed and/or propagated.
  16
  17    Bacula(R) is a registered trademark of Kern Sibbald.
  18 */
  19 /*
  20  *
  21  *   record-util.c -- Utilities for record handling
  22  *
  23  *            Kern Sibbald, October MMXII
  24  *
  25  */
  26
  27 #include "bacula.h"
  28 #include "stored.h"
  29
  30 /*
  31  * Convert a FileIndex into a printable
  32  *   ASCII string.  Not reentrant.
  33  * If the FileIndex is negative, it flags the
  34  *   record as a Label, otherwise it is simply
  35  *   the FileIndex of the current file.
  36  */
  37 const char *FI_to_ascii(char *buf, int fi)
  38 {
  39    if (fi >= 0) {
  40       sprintf(buf, "%d", fi);
  41       return buf;
  42    }
  43    switch (fi) {
  44    case PRE_LABEL:
  45       return "PRE_LABEL";
  46    case VOL_LABEL:
  47       return "VOL_LABEL";
  48    case EOM_LABEL:
  49       return "EOM_LABEL";
  50    case SOS_LABEL:
  51       return "SOS_LABEL";
  52    case EOS_LABEL:
  53       return "EOS_LABEL";
  54    case EOT_LABEL:
  55       return "EOT_LABEL";
  56       break;
  57    case SOB_LABEL:
  58       return "SOB_LABEL";
  59       break;
  60    case EOB_LABEL:
  61       return "EOB_LABEL";
  62       break;
  63    default:
  64      sprintf(buf, _("unknown: %d"), fi);
  65      return buf;
  66    }
  67 }
  68
  69 /*
  70  * Convert a Stream ID into a printable
  71  * ASCII string.  Not reentrant.
  72
  73  * A negative stream number represents
  74  *   stream data that is continued from a
  75  *   record in the previous block.
  76  * If the FileIndex is negative, we are
  77  *   dealing with a Label, hence the
  78  *   stream is the JobId.
  79  */
  80 const char *stream_to_ascii(char *buf, int stream, int fi)
  81 {
  82
  83    if (fi < 0) {
  84       sprintf(buf, "%d", stream);
  85       return buf;
  86    }
  87    if (stream < 0) {
  88       stream = -stream;
  89       stream &= STREAMMASK_TYPE;
  90       /* Stream was negative => all are continuation items */
  91       switch (stream) {
  92       case STREAM_UNIX_ATTRIBUTES:
  93          return "contUATTR";
  94       case STREAM_FILE_DATA:
  95          return "contDATA";
  96       case STREAM_WIN32_DATA:
  97          return "contWIN32-DATA";
  98       case STREAM_WIN32_GZIP_DATA:
  99          return "contWIN32-GZIP";
 100       case STREAM_WIN32_COMPRESSED_DATA:
 101          return "contWIN32-COMPRESSED";
 102       case STREAM_MD5_DIGEST:
 103          return "contMD5";
 104       case STREAM_SHA1_DIGEST:
 105          return "contSHA1";
 106       case STREAM_GZIP_DATA:
 107          return "contGZIP";
 108       case STREAM_COMPRESSED_DATA:
 109          return "contCOMPRESSED";
 110       case STREAM_UNIX_ATTRIBUTES_EX:
 111          return "contUNIX-ATTR-EX";
 112       case STREAM_RESTORE_OBJECT:
 113          return "contRESTORE-OBJECT";
 114       case STREAM_SPARSE_DATA:
 115          return "contSPARSE-DATA";
 116       case STREAM_SPARSE_GZIP_DATA:
 117          return "contSPARSE-GZIP";
 118       case STREAM_SPARSE_COMPRESSED_DATA:
 119          return "contSPARSE-COMPRESSED";
 120       case STREAM_PROGRAM_NAMES:
 121          return "contPROG-NAMES";
 122       case STREAM_PROGRAM_DATA:
 123          return "contPROG-DATA";
 124       case STREAM_MACOS_FORK_DATA:
 125          return "contMACOS-RSRC";
 126       case STREAM_HFSPLUS_ATTRIBUTES:
 127          return "contHFSPLUS-ATTR";
 128       case STREAM_SHA256_DIGEST:
 129          return "contSHA256";
 130       case STREAM_SHA512_DIGEST:
 131          return "contSHA512";
 132       case STREAM_SIGNED_DIGEST:
 133          return "contSIGNED-DIGEST";
 134       case STREAM_ENCRYPTED_SESSION_DATA:
 135          return "contENCRYPTED-SESSION-DATA";
 136       case STREAM_ENCRYPTED_FILE_DATA:
 137          return "contENCRYPTED-FILE";
 138       case STREAM_ENCRYPTED_FILE_GZIP_DATA:
 139          return "contENCRYPTED-GZIP";
 140       case STREAM_ENCRYPTED_FILE_COMPRESSED_DATA:
 141          return "contENCRYPTED-COMPRESSED";
 142       case STREAM_ENCRYPTED_WIN32_DATA:
 143          return "contENCRYPTED-WIN32-DATA";
 144       case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
 145          return "contENCRYPTED-WIN32-GZIP";
 146       case STREAM_ENCRYPTED_WIN32_COMPRESSED_DATA:
 147          return "contENCRYPTED-WIN32-COMPRESSED";
 148       case STREAM_ENCRYPTED_MACOS_FORK_DATA:
 149          return "contENCRYPTED-MACOS-RSRC";
 150       case STREAM_PLUGIN_NAME:
 151          return "contPLUGIN-NAME";
 152       case STREAM_ADATA_BLOCK_HEADER:
 153          return "contADATA-BLOCK-HEADER";
 154       case STREAM_ADATA_RECORD_HEADER:
 155          return "contADATA-RECORD-HEADER";
 156
 157       default:
 158          sprintf(buf, "%d", -stream);
 159          return buf;
 160       }
 161    }
 162
 163    switch (stream & STREAMMASK_TYPE) {
 164    case STREAM_UNIX_ATTRIBUTES:
 165       return "UATTR";
 166    case STREAM_FILE_DATA:
 167       return "DATA";
 168    case STREAM_WIN32_DATA:
 169       return "WIN32-DATA";
 170    case STREAM_WIN32_GZIP_DATA:
 171       return "WIN32-GZIP";
 172    case STREAM_WIN32_COMPRESSED_DATA:
 173       return "WIN32-COMPRESSED";
 174    case STREAM_MD5_DIGEST:
 175       return "MD5";
 176    case STREAM_SHA1_DIGEST:
 177       return "SHA1";
 178    case STREAM_GZIP_DATA:
 179       return "GZIP";
 180    case STREAM_COMPRESSED_DATA:
 181       return "COMPRESSED";
 182    case STREAM_UNIX_ATTRIBUTES_EX:
 183       return "UNIX-ATTR-EX";
 184    case STREAM_RESTORE_OBJECT:
 185       return "RESTORE-OBJECT";
 186    case STREAM_SPARSE_DATA:
 187       return "SPARSE-DATA";
 188    case STREAM_SPARSE_GZIP_DATA:
 189       return "SPARSE-GZIP";
 190    case STREAM_SPARSE_COMPRESSED_DATA:
 191       return "SPARSE-COMPRESSED";
 192    case STREAM_PROGRAM_NAMES:
 193       return "PROG-NAMES";
 194    case STREAM_PROGRAM_DATA:
 195       return "PROG-DATA";
 196    case STREAM_PLUGIN_NAME:
 197       return "PLUGIN-NAME";
 198    case STREAM_MACOS_FORK_DATA:
 199       return "MACOS-RSRC";
 200    case STREAM_HFSPLUS_ATTRIBUTES:
 201       return "HFSPLUS-ATTR";
 202    case STREAM_SHA256_DIGEST:
 203       return "SHA256";
 204    case STREAM_SHA512_DIGEST:
 205       return "SHA512";
 206    case STREAM_SIGNED_DIGEST:
 207       return "SIGNED-DIGEST";
 208    case STREAM_ENCRYPTED_SESSION_DATA:
 209       return "ENCRYPTED-SESSION-DATA";
 210    case STREAM_ENCRYPTED_FILE_DATA:
 211       return "ENCRYPTED-FILE";
 212    case STREAM_ENCRYPTED_FILE_GZIP_DATA:
 213       return "ENCRYPTED-GZIP";
 214    case STREAM_ENCRYPTED_FILE_COMPRESSED_DATA:
 215       return "ENCRYPTED-COMPRESSED";
 216    case STREAM_ENCRYPTED_WIN32_DATA:
 217       return "ENCRYPTED-WIN32-DATA";
 218    case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
 219       return "ENCRYPTED-WIN32-GZIP";
 220    case STREAM_ENCRYPTED_WIN32_COMPRESSED_DATA:
 221       return "ENCRYPTED-WIN32-COMPRESSED";
 222    case STREAM_ENCRYPTED_MACOS_FORK_DATA:
 223       return "ENCRYPTED-MACOS-RSRC";
 224    case STREAM_ADATA_BLOCK_HEADER:
 225       return "ADATA-BLOCK-HEADER";
 226    case STREAM_ADATA_RECORD_HEADER:
 227       return "ADATA-RECORD-HEADER";
 228    default:
 229       sprintf(buf, "%d", stream);
 230       return buf;
 231    }
 232 }
 233
 234 const char *stream_to_ascii_ex(char *buf, int stream, int fi)
 235 {
 236    if (fi < 0) {
 237       return stream_to_ascii(buf, stream, fi);
 238    }
 239    const char *p = stream_to_ascii(buf, stream, fi);
 240    return p;
 241 }
 242 /*
 243  * Return a new record entity
 244  */
 245 DEV_RECORD *new_record(void)
 246 {
 247    DEV_RECORD *rec;
 248
 249    rec = (DEV_RECORD *)get_memory(sizeof(DEV_RECORD));
 250    memset(rec, 0, sizeof(DEV_RECORD));
 251    rec->data = get_pool_memory(PM_MESSAGE);
 252    rec->wstate = st_none;
 253    rec->rstate = st_none;
 254    return rec;
 255 }
 256
 257 void empty_record(DEV_RECORD *rec)
 258 {
 259    rec->RecNum = 0;
 260    rec->StartAddr = rec->Addr = 0;
 261    rec->VolSessionId = rec->VolSessionTime = 0;
 262    rec->FileIndex = rec->Stream = 0;
 263    rec->data_len = rec->remainder = 0;
 264    rec->state_bits &= ~(REC_PARTIAL_RECORD|REC_ADATA_EMPTY|REC_BLOCK_EMPTY|REC_NO_MATCH|REC_CONTINUATION);
 265    rec->FileOffset = 0;
 266    rec->wstate = st_none;
 267    rec->rstate = st_none;
 268    rec->VolumeName = NULL;
 269 }
 270
 271 /*
 272  * Free the record entity
 273  *
 274  */
 275 void free_record(DEV_RECORD *rec)
 276 {
 277    Dmsg0(950, "Enter free_record.\n");
 278    if (rec->data) {
 279       free_pool_memory(rec->data);
 280    }
 281    Dmsg0(950, "Data buf is freed.\n");
 282    free_pool_memory((POOLMEM *)rec);
 283    Dmsg0(950, "Leave free_record.\n");
 284 }
 285
 286 void dump_record(DEV_RECORD *rec)
 287 {
 288    char buf[32];
 289    Dmsg11(100|DT_VOLUME, "Dump record %s 0x%p:\n\tStart=%lld addr=%lld #%d\n"
 290          "\tVolSess: %ld:%ld\n"
 291          "\tFileIndex: %ld\n"
 292          "\tStream: 0x%lx\n\tLen: %ld\n\tData: %s\n",
 293          rec, NPRT(rec->VolumeName),
 294          rec->StartAddr, rec->Addr, rec->RecNum,
 295          rec->VolSessionId, rec->VolSessionTime, rec->FileIndex,
 296          rec->Stream, rec->data_len,
 297          asciidump(rec->data, rec->data_len, buf, sizeof(buf)));
 298 }
 299
 300 /*
 301  * Test if we can write whole record to the block
 302  *
 303  *  Returns: false on failure
 304  *           true  on success (all bytes can be written)
 305  */
 306 bool can_write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec)
 307 {
 308    uint32_t remlen;
 309
 310    remlen = block->buf_len - block->binbuf;
 311    if (rec->remainder == 0) {
 312       if (remlen >= WRITE_RECHDR_LENGTH) {
 313          remlen -= WRITE_RECHDR_LENGTH;
 314          rec->remainder = rec->data_len;
 315       } else {
 316          return false;
 317       }
 318    } else {
 319       return false;
 320    }
 321    if (rec->remainder > 0 && remlen < rec->remainder) {
 322       return false;
 323    }
 324    return true;
 325 }
 326
 327 uint64_t get_record_address(DEV_RECORD *rec)
 328 {
 329      return rec->Addr;
 330 }
 331
 332 uint64_t get_record_start_address(DEV_RECORD *rec)
 333 {
 334      return rec->StartAddr;
 335 }