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

   1 /*
   2  *
   3  *  label.c  Bacula routines to handle labels
   4  *
   5  *   Kern Sibbald, MM
   6  *
   7  *
   8  *   Version $Id$
   9  */
  10 /*
  11    Copyright (C) 2000-2005 Kern Sibbald
  12
  13    This program is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU General Public License as
  15    published by the Free Software Foundation; either version 2 of
  16    the License, or (at your option) any later version.
  17
  18    This program is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  21    General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public
  24    License along with this program; if not, write to the Free
  25    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  26    MA 02111-1307, USA.
  27
  28  */
  29
  30 #include "bacula.h"                   /* pull in global headers */
  31 #include "stored.h"                   /* pull in Storage Deamon headers */
  32
  33 /* Forward referenced functions */
  34 static void create_volume_label_record(DCR *dcr, DEV_RECORD *rec);
  35 static int read_ansi_ibm_label(DCR *dcr);
  36 static char *ansi_date(time_t td, char *buf);
  37
  38 extern char my_name[];
  39 extern int debug_level;
  40
  41 /*
  42  * Read the volume label
  43  *
  44  *  If dcr->VolumeName == NULL, we accept any Bacula Volume
  45  *  If dcr->VolumeName[0] == 0, we accept any Bacula Volume
  46  *  otherwise dcr->VolumeName must match the Volume.
  47  *
  48  *  If VolName given, ensure that it matches
  49  *
  50  *  Returns VOL_  code as defined in record.h
  51  *    VOL_NOT_READ
  52  *    VOL_OK
  53  *    VOL_NO_LABEL
  54  *    VOL_IO_ERROR
  55  *    VOL_NAME_ERROR
  56  *    VOL_CREATE_ERROR
  57  *    VOL_VERSION_ERROR
  58  *    VOL_LABEL_ERROR
  59  *    VOL_NO_MEDIA
  60  */
  61 int read_dev_volume_label(DCR *dcr)
  62 {
  63    JCR *jcr = dcr->jcr;
  64    DEVICE *dev = dcr->dev;
  65    char *VolName = dcr->VolumeName;
  66    DEV_RECORD *record;
  67    bool ok = false;
  68    DEV_BLOCK *block = dcr->block;
  69
  70    Dmsg3(100, "Enter read_volume_label device=%s vol=%s dev_Vol=%s\n",
  71       dev_name(dev), VolName, dev->VolHdr.VolName);
  72
  73    if (!dev->is_open()) {
  74       Emsg0(M_ABORT, 0, _("BAD call to read_dev_volume_label\n"));
  75    }
  76    if (dev->is_labeled()) {              /* did we already read label? */
  77       /* Compare Volume Names allow special wild card */
  78       if (VolName && *VolName && *VolName != '*' && strcmp(dev->VolHdr.VolName, VolName) != 0) {
  79          Mmsg(jcr->errmsg, _("Wrong Volume mounted on device %s: Wanted %s have %s\n"),
  80             dev_name(dev), VolName, dev->VolHdr.VolName);
  81          /*
  82           * Cancel Job if too many label errors
  83           *  => we are in a loop
  84           */
  85          if (!dev->poll && jcr->label_errors++ > 100) {
  86             Jmsg(jcr, M_FATAL, 0, "Too many tries: %s", jcr->errmsg);
  87          }
  88          return VOL_NAME_ERROR;
  89       }
  90       Dmsg0(30, "Leave read_volume_label() VOL_OK\n");
  91       return VOL_OK;       /* label already read */
  92    }
  93
  94    dev->state &= ~(ST_LABEL|ST_APPEND|ST_READ);  /* set no label, no append */
  95
  96    if (!rewind_dev(dev)) {
  97       Mmsg(jcr->errmsg, _("Couldn't rewind device %s ERR=%s\n"), dev_name(dev),
  98          strerror_dev(dev));
  99       Dmsg1(30, "%s", jcr->errmsg);
 100       return VOL_NO_MEDIA;
 101    }
 102    bstrncpy(dev->VolHdr.Id, "**error**", sizeof(dev->VolHdr.Id));
 103
 104   /* Read ANSI/IBM label if so requested */
 105   int stat = read_ansi_ibm_label(dcr);
 106   if (stat != VOL_OK) {
 107       return stat;
 108    }
 109
 110    /* Read the Volume label block */
 111    record = new_record();
 112    empty_block(block);
 113    Dmsg0(90, "Big if statement in read_volume_label\n");
 114    if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
 115       Mmsg(jcr->errmsg, _("Requested Volume \"%s\" on %s is not a Bacula "
 116            "labeled Volume, because: ERR=%s"), NPRT(VolName), dev_name(dev),
 117            strerror_dev(dev));
 118       Dmsg1(30, "%s", jcr->errmsg);
 119    } else if (!read_record_from_block(block, record)) {
 120       Mmsg(jcr->errmsg, _("Could not read Volume label from block.\n"));
 121       Dmsg1(30, "%s", jcr->errmsg);
 122    } else if (!unser_volume_label(dev, record)) {
 123       Mmsg(jcr->errmsg, _("Could not unserialize Volume label: ERR=%s\n"),
 124          strerror_dev(dev));
 125       Dmsg1(30, "%s", jcr->errmsg);
 126    } else if (strcmp(dev->VolHdr.Id, BaculaId) != 0 &&
 127               strcmp(dev->VolHdr.Id, OldBaculaId) != 0) {
 128       Mmsg(jcr->errmsg, _("Volume Header Id bad: %s\n"), dev->VolHdr.Id);
 129       Dmsg1(30, "%s", jcr->errmsg);
 130    } else {
 131       ok = true;
 132    }
 133    if (!ok) {
 134       free_record(record);
 135       if (forge_on || jcr->ignore_label_errors) {
 136          dev->state |= ST_LABEL;      /* set has Bacula label */
 137          Jmsg(jcr, M_ERROR, 0, "%s", jcr->errmsg);
 138          return VOL_OK;
 139       }
 140       empty_block(block);
 141       rewind_dev(dev);
 142       return VOL_NO_LABEL;
 143    }
 144
 145    free_record(record);
 146    /* If we are a streaming device, we only get one chance to read */
 147    if (!dev_cap(dev, CAP_STREAM)) {
 148       empty_block(block);
 149       rewind_dev(dev);
 150    }
 151
 152    if (dev->VolHdr.VerNum != BaculaTapeVersion &&
 153        dev->VolHdr.VerNum != OldCompatibleBaculaTapeVersion1 &&
 154        dev->VolHdr.VerNum != OldCompatibleBaculaTapeVersion2) {
 155       Mmsg(jcr->errmsg, _("Volume on %s has wrong Bacula version. Wanted %d got %d\n"),
 156          dev_name(dev), BaculaTapeVersion, dev->VolHdr.VerNum);
 157       Dmsg1(30, "%s", jcr->errmsg);
 158       return VOL_VERSION_ERROR;
 159    }
 160
 161    /* We are looking for either an unused Bacula tape (PRE_LABEL) or
 162     * a Bacula volume label (VOL_LABEL)
 163     */
 164    if (dev->VolHdr.LabelType != PRE_LABEL && dev->VolHdr.LabelType != VOL_LABEL) {
 165       Mmsg(jcr->errmsg, _("Volume on %s has bad Bacula label type: %x\n"),
 166           dev_name(dev), dev->VolHdr.LabelType);
 167       Dmsg1(30, "%s", jcr->errmsg);
 168       return VOL_LABEL_ERROR;
 169    }
 170
 171    dev->state |= ST_LABEL;            /* set has Bacula label */
 172
 173    /* Compare Volume Names */
 174    Dmsg2(30, "Compare Vol names: VolName=%s hdr=%s\n", VolName?VolName:"*", dev->VolHdr.VolName);
 175    if (VolName && *VolName && *VolName != '*' && strcmp(dev->VolHdr.VolName, VolName) != 0) {
 176       Mmsg(jcr->errmsg, _("Wrong Volume mounted on device %s: Wanted %s have %s\n"),
 177            dev_name(dev), VolName, dev->VolHdr.VolName);
 178       Dmsg1(30, "%s", jcr->errmsg);
 179       /*
 180        * Cancel Job if too many label errors
 181        *  => we are in a loop
 182        */
 183       if (!dev->poll && jcr->label_errors++ > 100) {
 184          Jmsg(jcr, M_FATAL, 0, "Too many tries: %s", jcr->errmsg);
 185       }
 186       return VOL_NAME_ERROR;
 187    }
 188    Dmsg1(30, "Copy vol_name=%s\n", dev->VolHdr.VolName);
 189
 190    if (debug_level >= 10) {
 191       dump_volume_label(dev);
 192    }
 193    Dmsg0(30, "Leave read_volume_label() VOL_OK\n");
 194    return VOL_OK;
 195 }
 196
 197 /* Read the volume label by guessing the volume name. (only for mounted devices)
 198  * write is true if we are reading the label before writing to the device.
 199  *
 200  * If the volume name cannot be guessed :
 201  *  Writing : returns the label of the current file (on the harddisk).
 202  *  Reading : returns an error
 203  */
 204 int read_dev_volume_label_guess(DCR *dcr, bool write)
 205 {
 206    int vol_label_status;
 207    DEVICE *dev = dcr->dev;
 208    JCR *jcr = dcr->jcr;
 209    Dmsg3(100, "Enter read_dev_volume_label_guess device=%s vol=%s dev_Vol=%s\n",
 210          dev_name(dev), dcr->VolumeName, dev->VolHdr.VolName);
 211
 212    if (!dev->is_dvd()) {
 213       Dmsg0(100, "Leave read_dev_volume_label_guess !CAP_REQMOUNT\n");
 214       return read_dev_volume_label(dcr);
 215    }
 216
 217    if (!write && (dcr->VolCatInfo.VolCatParts == 0)) {
 218       Dmsg0(100, "Leave read_dev_volume_label_guess !writing, and VolCatParts == 0\n");
 219       return read_dev_volume_label(dcr);
 220    }
 221
 222    /* For mounted devices, tries to guess the volume name, and read the label if possible.
 223    */
 224    if (open_guess_name_dev(dev) < 0) {
 225       if ((!write) || (dcr->VolCatInfo.VolCatParts > 0)) {
 226          Mmsg2(jcr->errmsg, _("Requested Volume \"%s\" on %s is not a Bacula labeled Volume."),
 227                dev_name(dev), dcr->VolumeName);
 228          Dmsg0(100, "Leave read_dev_volume_label_guess VOL_IO_ERROR (!open_guess_name_dev)\n");
 229          return VOL_NO_LABEL;
 230       }
 231
 232       if (write && (dev->free_space_errno < 0)) {
 233          Dmsg0(100, "Leave read_dev_volume_label_guess !free_space VOL_NO_MEDIA\n");
 234          Mmsg2(jcr->errmsg, _("free_space error on %s. The current medium is probably not writable. ERR=%s.\n"),
 235                dev->dev_name, dev->errmsg);
 236          return VOL_NO_MEDIA;
 237       }
 238
 239       /* If we can't guess the name, and we are writing, just reopen the right file with open_first_part. */
 240       if (open_first_part(dev) < 0) {
 241          berrno be;
 242          Mmsg2(jcr->errmsg, _("open_first_part error on %s. ERR=%s.\n"),
 243                dev->dev_name, be.strerror());
 244          Dmsg0(100, "Leave read_dev_volume_label_guess VOL_IO_ERROR (!open_guess_name_dev && !open_first_part)\n");
 245          return VOL_IO_ERROR;
 246       }
 247
 248       Dmsg0(100, "Leave read_dev_volume_label_guess !open_guess_name_dev\n");
 249       return read_dev_volume_label(dcr);
 250    } else {
 251       if (write && (dcr->dev->free_space_errno < 0)) {
 252          Dmsg0(100, "Leave read_dev_volume_label_guess !free_space VOL_NO_MEDIA\n");
 253          Mmsg2(jcr->errmsg, _("free_space error on %s. The current medium is probably not writable. ERR=%s.\n"),
 254                dev->dev_name, dev->errmsg);
 255          return VOL_NO_MEDIA;
 256       }
 257
 258       vol_label_status = read_dev_volume_label(dcr);
 259
 260       if ((!write) || (dcr->VolCatInfo.VolCatParts > 0)) {
 261          Dmsg0(100, "Leave read_dev_volume_label_guess (open_guess_name_dev && (!write || dcr->VolCatInfo.VolCatParts > 0))\n");
 262          return vol_label_status;
 263       }
 264
 265       if (open_first_part(dcr->dev) < 0) {
 266          berrno be;
 267          Mmsg2(jcr->errmsg, _("open_first_part error on %s. ERR=%s.\n"),
 268                dev->dev_name, be.strerror());
 269          Dmsg0(100, "Leave read_dev_volume_label_guess VOL_IO_ERROR (open_guess_name_dev && !open_first_part)\n");
 270          return VOL_IO_ERROR;
 271       }
 272
 273       /* When writing, if the guessed volume name is no the right volume name,
 274        * report the error, otherwise, just continue with the right file.
 275        */
 276       if (vol_label_status != VOL_NAME_ERROR) {
 277          Dmsg0(100, "Leave read_dev_volume_label_guess (open_guess_name_dev && !VOL_NAME_ERROR)\n");
 278          dev->state &= ~ST_LABEL;
 279          return read_dev_volume_label(dcr);
 280       }
 281       else {
 282          Dmsg0(100, "Leave read_dev_volume_label_guess (open_guess_name_dev && VOL_NAME_ERROR)\n");
 283          return vol_label_status;
 284       }
 285    }
 286 }
 287
 288 /*  unser_volume_label
 289  *
 290  * Unserialize the Bacula Volume label into the device Volume_Label
 291  * structure.
 292  *
 293  * Assumes that the record is already read.
 294  *
 295  * Returns: false on error
 296  *          true  on success
 297 */
 298
 299 bool unser_volume_label(DEVICE *dev, DEV_RECORD *rec)
 300 {
 301    ser_declare;
 302
 303    if (rec->FileIndex != VOL_LABEL && rec->FileIndex != PRE_LABEL) {
 304       Mmsg3(dev->errmsg, _("Expecting Volume Label, got FI=%s Stream=%s len=%d\n"),
 305               FI_to_ascii(rec->FileIndex),
 306               stream_to_ascii(rec->Stream, rec->FileIndex),
 307               rec->data_len);
 308       if (!forge_on) {
 309          return false;
 310       }
 311    }
 312
 313    dev->VolHdr.LabelType = rec->FileIndex;
 314    dev->VolHdr.LabelSize = rec->data_len;
 315
 316
 317    /* Unserialize the record into the Volume Header */
 318    rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Volume_Label);
 319    ser_begin(rec->data, SER_LENGTH_Volume_Label);
 320    unser_string(dev->VolHdr.Id);
 321    unser_uint32(dev->VolHdr.VerNum);
 322
 323    if (dev->VolHdr.VerNum >= 11) {
 324       unser_btime(dev->VolHdr.label_btime);
 325       unser_btime(dev->VolHdr.write_btime);
 326    } else { /* old way */
 327       unser_float64(dev->VolHdr.label_date);
 328       unser_float64(dev->VolHdr.label_time);
 329    }
 330    unser_float64(dev->VolHdr.write_date);    /* Unused with VerNum >= 11 */
 331    unser_float64(dev->VolHdr.write_time);    /* Unused with VerNum >= 11 */
 332
 333    unser_string(dev->VolHdr.VolName);
 334    unser_string(dev->VolHdr.PrevVolName);
 335    unser_string(dev->VolHdr.PoolName);
 336    unser_string(dev->VolHdr.PoolType);
 337    unser_string(dev->VolHdr.MediaType);
 338
 339    unser_string(dev->VolHdr.HostName);
 340    unser_string(dev->VolHdr.LabelProg);
 341    unser_string(dev->VolHdr.ProgVersion);
 342    unser_string(dev->VolHdr.ProgDate);
 343
 344    ser_end(rec->data, SER_LENGTH_Volume_Label);
 345    Dmsg0(90, "ser_read_vol\n");
 346    if (debug_level >= 90) {
 347       dump_volume_label(dev);
 348    }
 349    return true;
 350 }
 351
 352 /*
 353  * Put a volume label into the block
 354  *
 355  *  Returns: false on failure
 356  *           true  on success
 357  */
 358 bool write_volume_label_to_block(DCR *dcr)
 359 {
 360    DEV_RECORD rec;
 361    DEVICE *dev = dcr->dev;
 362    JCR *jcr = dcr->jcr;
 363    DEV_BLOCK *block = dcr->block;
 364
 365    Dmsg0(20, "write Label in write_volume_label_to_block()\n");
 366    memset(&rec, 0, sizeof(rec));
 367    rec.data = get_memory(SER_LENGTH_Volume_Label);
 368    empty_block(block);                /* Volume label always at beginning */
 369
 370    create_volume_label_record(dcr, &rec);
 371
 372    block->BlockNumber = 0;
 373    if (!write_record_to_block(block, &rec)) {
 374       free_pool_memory(rec.data);
 375       Jmsg1(jcr, M_FATAL, 0, _("Cannot write Volume label to block for device %s\n"),
 376          dev_name(dev));
 377       return false;
 378    } else {
 379       Dmsg1(90, "Wrote label of %d bytes to block\n", rec.data_len);
 380    }
 381    free_pool_memory(rec.data);
 382    return true;
 383 }
 384
 385 /*
 386  *  create_volume_label_record
 387  *   Serialize label (from dev->VolHdr structure) into device record.
 388  *   Assumes that the dev->VolHdr structure is properly
 389  *   initialized.
 390 */
 391 static void create_volume_label_record(DCR *dcr, DEV_RECORD *rec)
 392 {
 393    ser_declare;
 394    struct date_time dt;
 395    DEVICE *dev = dcr->dev;
 396    JCR *jcr = dcr->jcr;
 397
 398    /* Serialize the label into the device record. */
 399
 400    rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Volume_Label);
 401    ser_begin(rec->data, SER_LENGTH_Volume_Label);
 402    ser_string(dev->VolHdr.Id);
 403
 404    ser_uint32(dev->VolHdr.VerNum);
 405
 406    if (dev->VolHdr.VerNum >= 11) {
 407       ser_btime(dev->VolHdr.label_btime);
 408       dev->VolHdr.write_btime = get_current_btime();
 409       ser_btime(dev->VolHdr.write_btime);
 410       dev->VolHdr.write_date = 0;
 411       dev->VolHdr.write_time = 0;
 412    } else {
 413       /* OLD WAY DEPRECATED */
 414       ser_float64(dev->VolHdr.label_date);
 415       ser_float64(dev->VolHdr.label_time);
 416       get_current_time(&dt);
 417       dev->VolHdr.write_date = dt.julian_day_number;
 418       dev->VolHdr.write_time = dt.julian_day_fraction;
 419    }
 420    ser_float64(dev->VolHdr.write_date);   /* 0 if VerNum >= 11 */
 421    ser_float64(dev->VolHdr.write_time);   /* 0  if VerNum >= 11 */
 422
 423    ser_string(dev->VolHdr.VolName);
 424    ser_string(dev->VolHdr.PrevVolName);
 425    ser_string(dev->VolHdr.PoolName);
 426    ser_string(dev->VolHdr.PoolType);
 427    ser_string(dev->VolHdr.MediaType);
 428
 429    ser_string(dev->VolHdr.HostName);
 430    ser_string(dev->VolHdr.LabelProg);
 431    ser_string(dev->VolHdr.ProgVersion);
 432    ser_string(dev->VolHdr.ProgDate);
 433
 434    ser_end(rec->data, SER_LENGTH_Volume_Label);
 435    rec->data_len = ser_length(rec->data);
 436    rec->FileIndex = dev->VolHdr.LabelType;
 437    rec->VolSessionId = jcr->VolSessionId;
 438    rec->VolSessionTime = jcr->VolSessionTime;
 439    rec->Stream = jcr->NumVolumes;
 440    Dmsg2(100, "Created Vol label rec: FI=%s len=%d\n", FI_to_ascii(rec->FileIndex),
 441       rec->data_len);
 442 }
 443
 444
 445 /*
 446  * Create a volume label in memory
 447  */
 448 void create_volume_label(DEVICE *dev, const char *VolName, const char *PoolName)
 449 {
 450    DEVRES *device = (DEVRES *)dev->device;
 451
 452    Dmsg0(90, "Start create_volume_label()\n");
 453
 454    ASSERT(dev != NULL);
 455
 456    memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
 457
 458    bstrncpy(dev->VolHdr.Id, BaculaId, sizeof(dev->VolHdr.Id));
 459    dev->VolHdr.VerNum = BaculaTapeVersion;
 460    dev->VolHdr.LabelType = PRE_LABEL;  /* Mark tape as unused */
 461    bstrncpy(dev->VolHdr.VolName, VolName, sizeof(dev->VolHdr.VolName));
 462    bstrncpy(dev->VolHdr.PoolName, PoolName, sizeof(dev->VolHdr.PoolName));
 463    bstrncpy(dev->VolHdr.MediaType, device->media_type, sizeof(dev->VolHdr.MediaType));
 464
 465    bstrncpy(dev->VolHdr.PoolType, "Backup", sizeof(dev->VolHdr.PoolType));
 466
 467    dev->VolHdr.label_btime = get_current_btime();
 468    dev->VolHdr.label_date = 0;
 469    dev->VolHdr.label_time = 0;
 470
 471    if (gethostname(dev->VolHdr.HostName, sizeof(dev->VolHdr.HostName)) != 0) {
 472       dev->VolHdr.HostName[0] = 0;
 473    }
 474    bstrncpy(dev->VolHdr.LabelProg, my_name, sizeof(dev->VolHdr.LabelProg));
 475    sprintf(dev->VolHdr.ProgVersion, "Ver. %s %s", VERSION, BDATE);
 476    sprintf(dev->VolHdr.ProgDate, "Build %s %s", __DATE__, __TIME__);
 477    dev->state |= ST_LABEL;            /* set has Bacula label */
 478    if (debug_level >= 90) {
 479       dump_volume_label(dev);
 480    }
 481 }
 482
 483 /*
 484  * Write a Volume Label
 485  *  !!! Note, this is ONLY used for writing
 486  *            a fresh volume label.  Any data
 487  *            after the label will be destroyed,
 488  *            in fact, we write the label 5 times !!!!
 489  *
 490  *  This routine expects that open_device() was previously called.
 491  *
 492  *  This routine should be used only when labeling a blank tape.
 493  */
 494 bool write_new_volume_label_to_dev(DCR *dcr, const char *VolName, const char *PoolName)
 495 {
 496    bool ok = false;
 497    DEVICE *dev = dcr->dev;
 498
 499
 500    Dmsg0(99, "write_volume_label()\n");
 501    empty_block(dcr->block);
 502    /* Create PRE_LABEL */
 503    create_volume_label(dev, VolName, PoolName);
 504
 505    if (!rewind_dev(dev)) {
 506       memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
 507       Dmsg2(30, "Bad status on %s from rewind. ERR=%s\n", dev_name(dev), strerror_dev(dev));
 508       if (!forge_on) {
 509          return false;
 510       }
 511    }
 512
 513    /* Write ANSI/IBM label if so requested */
 514    if (!write_ansi_ibm_label(dcr, VolName)) {
 515       goto bail_out;
 516    }
 517
 518    create_volume_label_record(dcr, dcr->rec);
 519    dcr->rec->Stream = 0;
 520
 521    /* Temporarily mark in append state to enable writing */
 522    dev->state |= ST_APPEND;
 523    if (!write_record_to_block(dcr->block, dcr->rec)) {
 524       Dmsg2(30, "Bad Label write on %s. ERR=%s\n", dev_name(dev), strerror_dev(dev));
 525       memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
 526       goto bail_out;
 527    } else {
 528       Dmsg2(30, "Wrote label of %d bytes to %s\n", dcr->rec->data_len, dev_name(dev));
 529    }
 530
 531    Dmsg0(99, "Call write_block_to_dev()\n");
 532    if (!write_block_to_dev(dcr)) {
 533       memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
 534       Dmsg2(30, "Bad Label write on %s. ERR=%s\n", dev_name(dev), strerror_dev(dev));
 535       goto bail_out;
 536    }
 537    Dmsg0(99, " Wrote block to device\n");
 538
 539    if (weof_dev(dev, 1) == 0) {
 540       dev->state |= ST_LABEL;
 541       ok = true;
 542    }
 543
 544    if (debug_level >= 20)  {
 545       dump_volume_label(dev);
 546    }
 547
 548 bail_out:
 549    dev->state &= ~ST_APPEND;          /* remove append since this is PRE_LABEL */
 550    return ok;
 551 }
 552
 553
 554 /*
 555  * Create session label
 556  *  The pool memory must be released by the calling program
 557  */
 558 void create_session_label(DCR *dcr, DEV_RECORD *rec, int label)
 559 {
 560    JCR *jcr = dcr->jcr;
 561    ser_declare;
 562
 563    rec->VolSessionId   = jcr->VolSessionId;
 564    rec->VolSessionTime = jcr->VolSessionTime;
 565    rec->Stream         = jcr->JobId;
 566
 567    rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Session_Label);
 568    ser_begin(rec->data, SER_LENGTH_Session_Label);
 569    ser_string(BaculaId);
 570    ser_uint32(BaculaTapeVersion);
 571
 572    ser_uint32(jcr->JobId);
 573
 574    /* Changed in VerNum 11 */
 575    ser_btime(get_current_btime());
 576    ser_float64(0);
 577
 578    ser_string(dcr->pool_name);
 579    ser_string(dcr->pool_type);
 580    ser_string(jcr->job_name);         /* base Job name */
 581    ser_string(jcr->client_name);
 582
 583    /* Added in VerNum 10 */
 584    ser_string(jcr->Job);              /* Unique name of this Job */
 585    ser_string(jcr->fileset_name);
 586    ser_uint32(jcr->JobType);
 587    ser_uint32(jcr->JobLevel);
 588    /* Added in VerNum 11 */
 589    ser_string(jcr->fileset_md5);
 590
 591    if (label == EOS_LABEL) {
 592       ser_uint32(jcr->JobFiles);
 593       ser_uint64(jcr->JobBytes);
 594       ser_uint32(dcr->StartBlock);
 595       ser_uint32(dcr->EndBlock);
 596       ser_uint32(dcr->StartFile);
 597       ser_uint32(dcr->EndFile);
 598       ser_uint32(jcr->JobErrors);
 599
 600       /* Added in VerNum 11 */
 601       ser_uint32(jcr->JobStatus);
 602    }
 603    ser_end(rec->data, SER_LENGTH_Session_Label);
 604    rec->data_len = ser_length(rec->data);
 605 }
 606
 607 /* Write session label
 608  *  Returns: false on failure
 609  *           true  on success
 610  */
 611 bool write_session_label(DCR *dcr, int label)
 612 {
 613    JCR *jcr = dcr->jcr;
 614    DEVICE *dev = dcr->dev;
 615    DEV_RECORD *rec;
 616    DEV_BLOCK *block = dcr->block;
 617
 618    rec = new_record();
 619    Dmsg1(90, "session_label record=%x\n", rec);
 620    switch (label) {
 621    case SOS_LABEL:
 622       if (dev->state & ST_TAPE) {
 623          dcr->StartBlock = dev->block_num;
 624          dcr->StartFile  = dev->file;
 625       } else {
 626          dcr->StartBlock = (uint32_t)dev->file_addr;
 627          dcr->StartFile = (uint32_t)(dev->file_addr >> 32);
 628       }
 629       break;
 630    case EOS_LABEL:
 631       if (dev->state & ST_TAPE) {
 632          dcr->EndBlock = dev->EndBlock;
 633          dcr->EndFile  = dev->EndFile;
 634       } else {
 635          dcr->EndBlock = (uint32_t)dev->file_addr;
 636          dcr->EndFile = (uint32_t)(dev->file_addr >> 32);
 637       }
 638       break;
 639    default:
 640       Jmsg1(jcr, M_ABORT, 0, _("Bad session label = %d\n"), label);
 641       break;
 642    }
 643    create_session_label(dcr, rec, label);
 644    rec->FileIndex = label;
 645
 646    /*
 647     * We guarantee that the session record can totally fit
 648     *  into a block. If not, write the block, and put it in
 649     *  the next block. Having the sesssion record totally in
 650     *  one block makes reading them much easier (no need to
 651     *  read the next block).
 652     */
 653    if (!can_write_record_to_block(block, rec)) {
 654       Dmsg0(100, "Cannot write session label to block.\n");
 655       if (!write_block_to_device(dcr)) {
 656          Dmsg0(90, "Got session label write_block_to_dev error.\n");
 657          /* ****FIXME***** errno is not set here */
 658          Jmsg(jcr, M_FATAL, 0, _("Error writing Session label to %s: %s\n"),
 659                            dev_vol_name(dev), strerror(errno));
 660          free_record(rec);
 661          return false;
 662       }
 663    }
 664    if (!write_record_to_block(block, rec)) {
 665       Jmsg(jcr, M_FATAL, 0, _("Error writing Session label to %s: %s\n"),
 666                         dev_vol_name(dev), strerror(errno));
 667       free_record(rec);
 668       return false;
 669    }
 670
 671    Dmsg6(20, "Write sesson_label record JobId=%d FI=%s SessId=%d Strm=%s len=%d "
 672              "remainder=%d\n", jcr->JobId,
 673       FI_to_ascii(rec->FileIndex), rec->VolSessionId,
 674       stream_to_ascii(rec->Stream, rec->FileIndex), rec->data_len,
 675       rec->remainder);
 676
 677    free_record(rec);
 678    Dmsg2(20, "Leave write_session_label Block=%d File=%d\n",
 679       dev->block_num, dev->file);
 680    return true;
 681 }
 682
 683 void dump_volume_label(DEVICE *dev)
 684 {
 685    int dbl = debug_level;
 686    uint32_t File;
 687    const char *LabelType;
 688    char buf[30];
 689    struct tm tm;
 690    struct date_time dt;
 691
 692    debug_level = 1;
 693    File = dev->file;
 694    switch (dev->VolHdr.LabelType) {
 695    case PRE_LABEL:
 696       LabelType = "PRE_LABEL";
 697       break;
 698    case VOL_LABEL:
 699       LabelType = "VOL_LABEL";
 700       break;
 701    case EOM_LABEL:
 702       LabelType = "EOM_LABEL";
 703       break;
 704    case SOS_LABEL:
 705       LabelType = "SOS_LABEL";
 706       break;
 707    case EOS_LABEL:
 708       LabelType = "EOS_LABEL";
 709       break;
 710    case EOT_LABEL:
 711       goto bail_out;
 712    default:
 713       LabelType = buf;
 714       sprintf(buf, "Unknown %d", dev->VolHdr.LabelType);
 715       break;
 716    }
 717
 718    Pmsg11(-1, "\nVolume Label:\n"
 719 "Id                : %s"
 720 "VerNo             : %d\n"
 721 "VolName           : %s\n"
 722 "PrevVolName       : %s\n"
 723 "VolFile           : %d\n"
 724 "LabelType         : %s\n"
 725 "LabelSize         : %d\n"
 726 "PoolName          : %s\n"
 727 "MediaType         : %s\n"
 728 "PoolType          : %s\n"
 729 "HostName          : %s\n"
 730 "",
 731              dev->VolHdr.Id, dev->VolHdr.VerNum,
 732              dev->VolHdr.VolName, dev->VolHdr.PrevVolName,
 733              File, LabelType, dev->VolHdr.LabelSize,
 734              dev->VolHdr.PoolName, dev->VolHdr.MediaType,
 735              dev->VolHdr.PoolType, dev->VolHdr.HostName);
 736
 737    if (dev->VolHdr.VerNum >= 11) {
 738       char dt[50];
 739       bstrftime(dt, sizeof(dt), btime_to_unix(dev->VolHdr.label_btime));
 740       Pmsg1(-1, "Date label written: %s\n", dt);
 741    } else {
 742    dt.julian_day_number   = dev->VolHdr.label_date;
 743    dt.julian_day_fraction = dev->VolHdr.label_time;
 744    tm_decode(&dt, &tm);
 745    Pmsg5(-1,
 746 "Date label written: %04d-%02d-%02d at %02d:%02d\n",
 747       tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday, tm.tm_hour, tm.tm_min);
 748    }
 749
 750 bail_out:
 751    debug_level = dbl;
 752 }
 753
 754 bool unser_session_label(SESSION_LABEL *label, DEV_RECORD *rec)
 755 {
 756    ser_declare;
 757
 758    rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Session_Label);
 759    unser_begin(rec->data, SER_LENGTH_Session_Label);
 760    unser_string(label->Id);
 761    unser_uint32(label->VerNum);
 762    unser_uint32(label->JobId);
 763    if (label->VerNum >= 11) {
 764       unser_btime(label->write_btime);
 765    } else {
 766       unser_float64(label->write_date);
 767    }
 768    unser_float64(label->write_time);
 769    unser_string(label->PoolName);
 770    unser_string(label->PoolType);
 771    unser_string(label->JobName);
 772    unser_string(label->ClientName);
 773    if (label->VerNum >= 10) {
 774       unser_string(label->Job);          /* Unique name of this Job */
 775       unser_string(label->FileSetName);
 776       unser_uint32(label->JobType);
 777       unser_uint32(label->JobLevel);
 778    }
 779    if (label->VerNum >= 11) {
 780       unser_string(label->FileSetMD5);
 781    } else {
 782       label->FileSetMD5[0] = 0;
 783    }
 784    if (rec->FileIndex == EOS_LABEL) {
 785       unser_uint32(label->JobFiles);
 786       unser_uint64(label->JobBytes);
 787       unser_uint32(label->StartBlock);
 788       unser_uint32(label->EndBlock);
 789       unser_uint32(label->StartFile);
 790       unser_uint32(label->EndFile);
 791       unser_uint32(label->JobErrors);
 792       if (label->VerNum >= 11) {
 793          unser_uint32(label->JobStatus);
 794       } else {
 795          label->JobStatus = JS_Terminated; /* kludge */
 796       }
 797    }
 798    return true;
 799 }
 800
 801
 802 static void dump_session_label(DEV_RECORD *rec, const char *type)
 803 {
 804    int dbl;
 805    struct date_time dt;
 806    struct tm tm;
 807    SESSION_LABEL label;
 808    char ec1[30], ec2[30], ec3[30], ec4[30], ec5[30], ec6[30], ec7[30];
 809
 810    unser_session_label(&label, rec);
 811    dbl = debug_level;
 812    debug_level = 1;
 813    Pmsg7(-1, "\n%s Record:\n"
 814 "JobId             : %d\n"
 815 "VerNum            : %d\n"
 816 "PoolName          : %s\n"
 817 "PoolType          : %s\n"
 818 "JobName           : %s\n"
 819 "ClientName        : %s\n"
 820 "",    type, label.JobId, label.VerNum,
 821       label.PoolName, label.PoolType,
 822       label.JobName, label.ClientName);
 823
 824    if (label.VerNum >= 10) {
 825       Pmsg4(-1, ""
 826 "Job (unique name) : %s\n"
 827 "FileSet           : %s\n"
 828 "JobType           : %c\n"
 829 "JobLevel          : %c\n"
 830 "", label.Job, label.FileSetName, label.JobType, label.JobLevel);
 831    }
 832
 833    if (rec->FileIndex == EOS_LABEL) {
 834       Pmsg8(-1, ""
 835 "JobFiles          : %s\n"
 836 "JobBytes          : %s\n"
 837 "StartBlock        : %s\n"
 838 "EndBlock          : %s\n"
 839 "StartFile         : %s\n"
 840 "EndFile           : %s\n"
 841 "JobErrors         : %s\n"
 842 "JobStatus         : %c\n"
 843 "",
 844          edit_uint64_with_commas(label.JobFiles, ec1),
 845          edit_uint64_with_commas(label.JobBytes, ec2),
 846          edit_uint64_with_commas(label.StartBlock, ec3),
 847          edit_uint64_with_commas(label.EndBlock, ec4),
 848          edit_uint64_with_commas(label.StartFile, ec5),
 849          edit_uint64_with_commas(label.EndFile, ec6),
 850          edit_uint64_with_commas(label.JobErrors, ec7),
 851          label.JobStatus);
 852    }
 853    if (label.VerNum >= 11) {
 854       char dt[50];
 855       bstrftime(dt, sizeof(dt), btime_to_unix(label.write_btime));
 856       Pmsg1(-1, _("Date written      : %s\n"), dt);
 857    } else {
 858       dt.julian_day_number   = label.write_date;
 859       dt.julian_day_fraction = label.write_time;
 860       tm_decode(&dt, &tm);
 861       Pmsg5(-1, _(""
 862 "Date written      : %04d-%02d-%02d at %02d:%02d\n"),
 863       tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday, tm.tm_hour, tm.tm_min);
 864    }
 865
 866    debug_level = dbl;
 867 }
 868
 869 void dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose)
 870 {
 871    const char *type;
 872    int dbl;
 873
 874    dbl = debug_level;
 875    debug_level = 1;
 876    switch (rec->FileIndex) {
 877    case PRE_LABEL:
 878       type = _("Fresh Volume");
 879       break;
 880    case VOL_LABEL:
 881       type = _("Volume");
 882       break;
 883    case SOS_LABEL:
 884       type = _("Begin Job Session");
 885       break;
 886    case EOS_LABEL:
 887       type = _("End Job Session");
 888       break;
 889    case EOM_LABEL:
 890       type = _("End of Media");
 891       break;
 892    case EOT_LABEL:
 893       type = ("End of Tape");
 894       break;
 895    default:
 896       type = _("Unknown");
 897       break;
 898    }
 899    if (verbose) {
 900       switch (rec->FileIndex) {
 901       case PRE_LABEL:
 902       case VOL_LABEL:
 903          unser_volume_label(dev, rec);
 904          dump_volume_label(dev);
 905          break;
 906       case SOS_LABEL:
 907          dump_session_label(rec, type);
 908          break;
 909       case EOS_LABEL:
 910          dump_session_label(rec, type);
 911          break;
 912       case EOM_LABEL:
 913          Pmsg5(-1, "%s Record: SessId=%d SessTime=%d JobId=%d DataLen=%d\n",
 914             type, rec->VolSessionId, rec->VolSessionTime, rec->Stream, rec->data_len);
 915          break;
 916       case EOT_LABEL:
 917          Pmsg0(-1, _("End of physical tape.\n"));
 918          break;
 919       default:
 920          Pmsg5(-1, "%s Record: SessId=%d SessTime=%d JobId=%d DataLen=%d\n",
 921             type, rec->VolSessionId, rec->VolSessionTime, rec->Stream, rec->data_len);
 922          break;
 923       }
 924    } else {
 925       SESSION_LABEL label;
 926       switch (rec->FileIndex) {
 927       case SOS_LABEL:
 928          unser_session_label(&label, rec);
 929          Pmsg6(-1, "%s Record: SessId=%d SessTime=%d JobId=%d Level=%c Type=%c\n",
 930             type, rec->VolSessionId, rec->VolSessionTime, rec->Stream,
 931             label.JobLevel, label.JobType);
 932          break;
 933       case EOS_LABEL:
 934          char ed1[30], ed2[30];
 935          unser_session_label(&label, rec);
 936          Pmsg6(-1, "%s Record: SessId=%d SessTime=%d JobId=%d Level=%c Type=%c\n",
 937             type, rec->VolSessionId, rec->VolSessionTime, rec->Stream,
 938             label.JobLevel, label.JobType);
 939          Pmsg4(-1, "   Files=%s Bytes=%s Errors=%d Status=%c\n",
 940             edit_uint64_with_commas(label.JobFiles, ed1),
 941             edit_uint64_with_commas(label.JobBytes, ed2),
 942             label.JobErrors, (char)label.JobStatus);
 943          break;
 944       case EOM_LABEL:
 945       case PRE_LABEL:
 946       case VOL_LABEL:
 947       default:
 948          Pmsg5(-1, "%s Record: SessId=%d SessTime=%d JobId=%d DataLen=%d\n",
 949       type, rec->VolSessionId, rec->VolSessionTime, rec->Stream, rec->data_len);
 950          break;
 951       case EOT_LABEL:
 952          break;
 953       }
 954    }
 955    debug_level = dbl;
 956 }
 957
 958 /*
 959  * Write an ANSI or IBM 80 character tape label
 960  *   Assume we are positioned at the beginning of the tape.
 961  *   Returns:  true of OK
 962  *             false if error
 963  */
 964 bool write_ansi_ibm_label(DCR *dcr, const char *VolName)
 965 {
 966    DEVICE *dev = dcr->dev;
 967    JCR *jcr = dcr->jcr;
 968    char label[80];                    /* tape label */
 969    char date[20];                     /* ansi date buffer */
 970    time_t now;
 971    int len;
 972    int stat;
 973
 974    switch (dcr->VolCatInfo.LabelType) {
 975    case B_BACULA_LABEL:
 976       return true;
 977    case B_ANSI_LABEL:
 978    case B_IBM_LABEL:
 979       ser_declare;
 980       Dmsg0(000, "Write ansi label.\n");
 981       len = strlen(VolName);
 982       if (len > 6) {
 983          len = 6;                        /* max len ANSI label */
 984       }
 985       memset(label, ' ', sizeof(label));
 986       ser_begin(label, sizeof(label));
 987       ser_bytes("VOL1", 4);
 988       ser_bytes(VolName, len);
 989       label[79] = '1';                /* ANSI label flag */
 990       /* Write VOL1 label */
 991       stat = write(dev->fd, label, sizeof(label));
 992       if (stat != sizeof(label)) {
 993          berrno be;
 994          Jmsg1(jcr, M_FATAL, 0,  _("Could not write ANSI VOL1 label. ERR=%s\n"),
 995             be.strerror());
 996          return false;
 997       }
 998       /* Now construct HDR1 label */
 999       ser_begin(label, sizeof(label));
1000       ser_bytes("HDR1", 4);
1001       len = strlen(VolName);
1002       if (len > 17) {
1003          len = 17;                    /* Max filename len */
1004       }
1005       ser_bytes(VolName, len);        /* stick Volume name in Filename field */
1006       if (len > 6) {
1007          len = 6;
1008       }
1009       ser_begin(&label[21], sizeof(label)-21);
1010       ser_bytes(VolName, len);        /* write Vol Ser No. */
1011       ser_begin(&label[27], sizeof(label)-27);
1012       ser_bytes("000100010001", 12);  /* File section, File seq no, Generation no */
1013       now = time(NULL);
1014       ser_bytes(ansi_date(now, date), 6); /* current date */
1015       ser_bytes(ansi_date(now - 24 * 3600, date), 6); /* created yesterday */
1016       ser_bytes(" 000000BACULA              ", 27);
1017       /* Write HDR1 label */
1018       stat = write(dev->fd, label, sizeof(label));
1019       if (stat != sizeof(label)) {
1020          berrno be;
1021          Jmsg1(jcr, M_FATAL, 0, _("Could not write ANSI HDR1 label. ERR=%s\n"),
1022             be.strerror());
1023          return false;
1024       }
1025       /* Now construct HDR2 label */
1026       memset(label, ' ', sizeof(label));
1027       ser_begin(label, sizeof(label));
1028       ser_bytes("HDR2F3200032000", 15);
1029       /* Write HDR1 label */
1030       stat = write(dev->fd, label, sizeof(label));
1031       if (stat != sizeof(label)) {
1032          berrno be;
1033          Jmsg1(jcr, M_FATAL, 0, _("Could not write ANSI HDR1 label. ERR=%s\n"),
1034             be.strerror());
1035          return false;
1036       }
1037       if (weof_dev(dev, 1) < 0) {
1038          Jmsg(jcr, M_FATAL, 0, _("Error writing EOF to tape. ERR=%s"), dev->errmsg);
1039          return false;
1040       }
1041       return true;
1042    default:
1043       Jmsg0(jcr, M_ABORT, 0, _("write_ansi_ibm_label called for non-ANSI/IBM type\n"));
1044       return false; /* should not get here */
1045    }
1046 }
1047
1048 static int read_ansi_ibm_label(DCR *dcr)
1049 {
1050    DEVICE *dev = dcr->dev;
1051    JCR *jcr = dcr->jcr;
1052    char label[80];                    /* tape label */
1053    int retry, stat, i, num_rec;
1054
1055    if (dcr->VolCatInfo.LabelType == B_BACULA_LABEL) {
1056       return VOL_OK;
1057    }
1058    /*
1059     * Read VOL1, HDR1, HDR2 labels, but ignore the data
1060     *  If tape read the following EOF mark, on disk do
1061     *  not read.
1062     */
1063    Dmsg0(000, "Read ansi label.\n");
1064    if (dev->state & ST_TAPE) {
1065       num_rec = 4;
1066    } else {
1067       num_rec = 3;
1068    }
1069    for (i=0; i < num_rec; i++) {
1070       retry = 0;
1071       do {
1072          stat = read(dev->fd, label, sizeof(label));
1073          if (retry == 1) {
1074             dev->VolCatInfo.VolCatErrors++;
1075          }
1076       } while (stat == -1 && (errno == EINTR || errno == EIO) && retry++ < 11);
1077       if (stat < 0) {
1078          berrno be;
1079          clrerror_dev(dev, -1);
1080          Dmsg1(200, "Read device got: ERR=%s\n", be.strerror());
1081          Mmsg2(dev->errmsg, _("Read error on device %s in ANSI/IBM label. ERR=%s\n"),
1082             dev->dev_name, be.strerror());
1083          Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
1084          if (dev->state & ST_EOF) {  /* EOF just seen? */
1085             dev->state |= ST_EOT;    /* yes, error => EOT */
1086          }
1087          return VOL_IO_ERROR;
1088       }
1089       Dmsg1(000, "ANSI label=%80s\n", label);
1090    }
1091    return VOL_OK;
1092 }
1093
1094
1095 static char *ansi_date(time_t td, char *buf)
1096 {
1097    struct tm *tm;
1098
1099    if (td == 0) {
1100       td = time(NULL);
1101    }
1102    tm = gmtime(&td);
1103    bsnprintf(buf, 6, "%d", 1000 * (tm->tm_year + 1900 - 2000) + tm->tm_yday);
1104    return buf;
1105 }