git.sur5r.net Git - bacula/bacula/blob - bacula/src/dird/ua_label.c

   1 /*
   2  *
   3  *   Bacula Director -- Tape labeling commands
   4  *
   5  *     Kern Sibbald, April MMIII
   6  *
   7  *   Version $Id$
   8  */
   9 /*
  10    Copyright (C) 2003-2006 Kern Sibbald
  11
  12    This program is free software; you can redistribute it and/or
  13    modify it under the terms of the GNU General Public License
  14    version 2 as amended with additional clauses defined in the
  15    file LICENSE in the main source directory.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20    the file LICENSE for additional details.
  21
  22  */
  23
  24 #include "bacula.h"
  25 #include "dird.h"
  26
  27 /* Slot list definition */
  28 typedef struct s_vol_list {
  29    struct s_vol_list *next;
  30    char *VolName;
  31    int Slot;
  32 } vol_list_t;
  33
  34
  35 /* Forward referenced functions */
  36 static int do_label(UAContext *ua, const char *cmd, int relabel);
  37 static void label_from_barcodes(UAContext *ua, int drive);
  38 static bool send_label_request(UAContext *ua, MEDIA_DBR *mr, MEDIA_DBR *omr,
  39                POOL_DBR *pr, int relabel, bool media_record_exits, int drive);
  40 static vol_list_t *get_vol_list_from_SD(UAContext *ua, bool scan);
  41 static void free_vol_list(vol_list_t *vol_list);
  42 static bool is_cleaning_tape(UAContext *ua, MEDIA_DBR *mr, POOL_DBR *pr);
  43 static BSOCK *open_sd_bsock(UAContext *ua);
  44 static void close_sd_bsock(UAContext *ua);
  45 static char *get_volume_name_from_SD(UAContext *ua, int Slot, int drive);
  46 static int get_num_slots_from_SD(UAContext *ua);
  47
  48
  49 /*
  50  * Label a tape
  51  *
  52  *   label storage=xxx volume=vvv
  53  */
  54 int label_cmd(UAContext *ua, const char *cmd)
  55 {
  56    return do_label(ua, cmd, 0);       /* standard label */
  57 }
  58
  59 int relabel_cmd(UAContext *ua, const char *cmd)
  60 {
  61    return do_label(ua, cmd, 1);      /* relabel tape */
  62 }
  63
  64 static bool get_user_slot_list(UAContext *ua, char *slot_list, int num_slots)
  65 {
  66    int i;
  67    const char *msg;
  68
  69    /* slots are numbered 1 to num_slots */
  70    for (int i=0; i <= num_slots; i++) {
  71       slot_list[i] = 0;
  72    }
  73    i = find_arg_with_value(ua, "slots");
  74    if (i > 0) {
  75       /* scan slot list in ua->argv[i] */
  76       char *p, *e, *h;
  77       int beg, end;
  78
  79       strip_trailing_junk(ua->argv[i]);
  80       for (p=ua->argv[i]; p && *p; p=e) {
  81          /* Check for list */
  82          e = strchr(p, ',');
  83          if (e) {
  84             *e++ = 0;
  85          }
  86          /* Check for range */
  87          h = strchr(p, '-');             /* range? */
  88          if (h == p) {
  89             msg = _("Negative numbers not permitted\n");
  90             goto bail_out;
  91          }
  92          if (h) {
  93             *h++ = 0;
  94             if (!is_an_integer(h)) {
  95                msg = _("Range end is not integer.\n");
  96                goto bail_out;
  97             }
  98             skip_spaces(&p);
  99             if (!is_an_integer(p)) {
 100                msg = _("Range start is not an integer.\n");
 101                goto bail_out;
 102             }
 103             beg = atoi(p);
 104             end = atoi(h);
 105             if (end < beg) {
 106                msg = _("Range end not bigger than start.\n");
 107                goto bail_out;
 108             }
 109          } else {
 110             skip_spaces(&p);
 111             if (!is_an_integer(p)) {
 112                msg = _("Input value is not an integer.\n");
 113                goto bail_out;
 114             }
 115             beg = end = atoi(p);
 116          }
 117          if (beg <= 0 || end <= 0) {
 118             msg = _("Values must be be greater than zero.\n");
 119             goto bail_out;
 120          }
 121          if (end > num_slots) {
 122             msg = _("Slot too large.\n");
 123             goto bail_out;
 124          }
 125          for (i=beg; i<=end; i++) {
 126             slot_list[i] = 1;         /* Turn on specified range */
 127          }
 128       }
 129    } else {
 130       /* Turn everything on */
 131       for (i=1; i <= num_slots; i++) {
 132          slot_list[i] = 1;
 133       }
 134    }
 135    Dmsg0(100, "Slots turned on:\n");
 136    for (i=1; i <= num_slots; i++) {
 137       if (slot_list[i]) {
 138          Dmsg1(100, "%d\n", i);
 139       }
 140    }
 141    return true;
 142
 143 bail_out:
 144    return false;
 145 }
 146
 147 /*
 148  * Update Slots corresponding to Volumes in autochanger
 149  */
 150 void update_slots(UAContext *ua)
 151 {
 152    STORE *store;
 153    vol_list_t *vl, *vol_list = NULL;
 154    MEDIA_DBR mr;
 155    char *slot_list;
 156    bool scan;
 157    int max_slots;
 158    int drive;
 159
 160
 161    if (!open_db(ua)) {
 162       return;
 163    }
 164    store = get_storage_resource(ua, true/*arg is storage*/);
 165    if (!store) {
 166       return;
 167    }
 168    set_wstorage(ua->jcr, store);
 169    drive = get_storage_drive(ua, store);
 170
 171    scan = find_arg(ua, NT_("scan")) >= 0;
 172
 173    max_slots = get_num_slots_from_SD(ua);
 174    Dmsg1(100, "max_slots=%d\n", max_slots);
 175    if (max_slots <= 0) {
 176       bsendmsg(ua, _("No slots in changer to scan.\n"));
 177       return;
 178    }
 179    slot_list = (char *)malloc(max_slots+1);
 180    if (!get_user_slot_list(ua, slot_list, max_slots)) {
 181       free(slot_list);
 182       return;
 183    }
 184
 185    vol_list = get_vol_list_from_SD(ua, scan);
 186
 187    if (!vol_list) {
 188       bsendmsg(ua, _("No Volumes found to label, or no barcodes.\n"));
 189       goto bail_out;
 190    }
 191
 192    /* First zap out any InChanger with StorageId=0 */
 193    db_sql_query(ua->db, "UPDATE Media SET InChanger=0 WHERE StorageId=0", NULL, NULL);
 194
 195    /* Walk through the list updating the media records */
 196    for (vl=vol_list; vl; vl=vl->next) {
 197       if (vl->Slot > max_slots) {
 198          bsendmsg(ua, _("Slot %d greater than max %d ignored.\n"),
 199             vl->Slot, max_slots);
 200          continue;
 201       }
 202       /* Check if user wants us to look at this slot */
 203       if (!slot_list[vl->Slot]) {
 204          Dmsg1(100, "Skipping slot=%d\n", vl->Slot);
 205          continue;
 206       }
 207       /* If scanning, we read the label rather than the barcode */
 208       if (scan) {
 209          if (vl->VolName) {
 210             free(vl->VolName);
 211             vl->VolName = NULL;
 212          }
 213          vl->VolName = get_volume_name_from_SD(ua, vl->Slot, drive);
 214          Dmsg2(100, "Got Vol=%s from SD for Slot=%d\n", vl->VolName, vl->Slot);
 215       }
 216       slot_list[vl->Slot] = 0;        /* clear Slot */
 217       memset(&mr, 0, sizeof(mr));
 218       mr.Slot = vl->Slot;
 219       mr.InChanger = 1;
 220       mr.StorageId = store->StorageId;
 221       /* Set InChanger to zero for this Slot */
 222       db_lock(ua->db);
 223       db_make_inchanger_unique(ua->jcr, ua->db, &mr);
 224       db_unlock(ua->db);
 225       if (!vl->VolName) {
 226          Dmsg1(000, "No VolName for Slot=%d setting InChanger to zero.\n", vl->Slot);
 227          bsendmsg(ua, _("No VolName for Slot=%d InChanger set to zero.\n"), vl->Slot);
 228          continue;
 229       }
 230       memset(&mr, 0, sizeof(mr));
 231       bstrncpy(mr.VolumeName, vl->VolName, sizeof(mr.VolumeName));
 232       db_lock(ua->db);
 233       if (db_get_media_record(ua->jcr, ua->db, &mr)) {
 234          if (mr.Slot != vl->Slot || !mr.InChanger || mr.StorageId != store->StorageId) {
 235             mr.Slot = vl->Slot;
 236             mr.InChanger = 1;
 237             mr.StorageId = store->StorageId;
 238             if (!db_update_media_record(ua->jcr, ua->db, &mr)) {
 239                bsendmsg(ua, "%s", db_strerror(ua->db));
 240             } else {
 241                bsendmsg(ua, _(
 242                  "Catalog record for Volume \"%s\" updated to reference slot %d.\n"),
 243                  mr.VolumeName, mr.Slot);
 244             }
 245          } else {
 246             bsendmsg(ua, _("Catalog record for Volume \"%s\" is up to date.\n"),
 247                mr.VolumeName);
 248          }
 249          db_unlock(ua->db);
 250          continue;
 251       } else {
 252          bsendmsg(ua, _("Volume \"%s\" not found in catalog. Slot=%d InChanger set to zero.\n"),
 253              mr.VolumeName, vl->Slot);
 254       }
 255       db_unlock(ua->db);
 256    }
 257    memset(&mr, 0, sizeof(mr));
 258    mr.InChanger = 1;
 259    mr.StorageId = store->StorageId;
 260    db_lock(ua->db);
 261    for (int i=1; i <= max_slots; i++) {
 262       if (slot_list[i]) {
 263          mr.Slot = i;
 264          /* Set InChanger to zero for this Slot */
 265          db_make_inchanger_unique(ua->jcr, ua->db, &mr);
 266       }
 267    }
 268    db_unlock(ua->db);
 269
 270 bail_out:
 271
 272    free_vol_list(vol_list);
 273    free(slot_list);
 274    close_sd_bsock(ua);
 275
 276    return;
 277 }
 278
 279
 280 /*
 281  * Common routine for both label and relabel
 282  */
 283 static int do_label(UAContext *ua, const char *cmd, int relabel)
 284 {
 285    STORE *store;
 286    BSOCK *sd;
 287    char dev_name[MAX_NAME_LENGTH];
 288    MEDIA_DBR mr, omr;
 289    POOL_DBR pr;
 290    bool print_reminder = true;
 291    bool label_barcodes = false;
 292    int ok = FALSE;
 293    int i, j;
 294    int drive;
 295    bool media_record_exists = false;
 296    static const char *barcode_keyword[] = {
 297       "barcode",
 298       "barcodes",
 299       NULL};
 300
 301
 302    memset(&pr, 0, sizeof(pr));
 303    if (!open_db(ua)) {
 304       return 1;
 305    }
 306
 307    /* Look for one of the barcode keywords */
 308    if (!relabel && (i=find_arg_keyword(ua, barcode_keyword)) >= 0) {
 309       /* Now find the keyword in the list */
 310       if ((j = find_arg(ua, barcode_keyword[i])) > 0) {
 311          *ua->argk[j] = 0;      /* zap barcode keyword */
 312       }
 313       label_barcodes = true;
 314    }
 315
 316    store = get_storage_resource(ua, true/*use default*/);
 317    if (!store) {
 318       return 1;
 319    }
 320    set_wstorage(ua->jcr, store);
 321    drive = get_storage_drive(ua, store);
 322
 323    if (label_barcodes) {
 324       label_from_barcodes(ua, drive);
 325       return 1;
 326    }
 327
 328    /* If relabel get name of Volume to relabel */
 329    if (relabel) {
 330       /* Check for oldvolume=name */
 331       i = find_arg_with_value(ua, "oldvolume");
 332       if (i >= 0) {
 333          memset(&omr, 0, sizeof(omr));
 334          bstrncpy(omr.VolumeName, ua->argv[i], sizeof(omr.VolumeName));
 335          if (db_get_media_record(ua->jcr, ua->db, &omr)) {
 336             goto checkVol;
 337          }
 338          bsendmsg(ua, "%s", db_strerror(ua->db));
 339       }
 340       /* No keyword or Vol not found, ask user to select */
 341       if (!select_media_dbr(ua, &omr)) {
 342          return 1;
 343       }
 344
 345       /* Require Volume to be Purged or Recycled */
 346 checkVol:
 347       if (strcmp(omr.VolStatus, "Purged") != 0 && strcmp(omr.VolStatus, "Recycle") != 0) {
 348          bsendmsg(ua, _("Volume \"%s\" has VolStatus %s. It must be Purged or Recycled before relabeling.\n"),
 349             omr.VolumeName, omr.VolStatus);
 350          return 1;
 351       }
 352    }
 353
 354    /* Check for volume=NewVolume */
 355    i = find_arg_with_value(ua, "volume");
 356    if (i >= 0) {
 357       pm_strcpy(ua->cmd, ua->argv[i]);
 358       goto checkName;
 359    }
 360
 361    /* Get a new Volume name */
 362    for ( ;; ) {
 363       media_record_exists = false;
 364       if (!get_cmd(ua, _("Enter new Volume name: "))) {
 365          return 1;
 366       }
 367 checkName:
 368       if (!is_volume_name_legal(ua, ua->cmd)) {
 369          continue;
 370       }
 371
 372       memset(&mr, 0, sizeof(mr));
 373       bstrncpy(mr.VolumeName, ua->cmd, sizeof(mr.VolumeName));
 374       /* If VolBytes are zero the Volume is not labeled */
 375       if (db_get_media_record(ua->jcr, ua->db, &mr)) {
 376          if (mr.VolBytes != 0) {
 377              bsendmsg(ua, _("Media record for new Volume \"%s\" already exists.\n"),
 378                 mr.VolumeName);
 379              continue;
 380           }
 381           media_record_exists = true;
 382       }
 383       break;                          /* Got it */
 384    }
 385
 386    /* If autochanger, request slot */
 387    i = find_arg_with_value(ua, "slot");
 388    if (i >= 0) {
 389       mr.Slot = atoi(ua->argv[i]);
 390       mr.InChanger = 1;               /* assumed if we are labeling it */
 391    } else if (store->autochanger) {
 392       if (!get_pint(ua, _("Enter slot (0 or Enter for none): "))) {
 393          return 1;
 394       }
 395       mr.Slot = ua->pint32_val;
 396       mr.InChanger = 1;               /* assumed if we are labeling it */
 397    }
 398    mr.StorageId = store->StorageId;
 399
 400    bstrncpy(mr.MediaType, store->media_type, sizeof(mr.MediaType));
 401
 402    /* Must select Pool if not already done */
 403    if (pr.PoolId == 0) {
 404       memset(&pr, 0, sizeof(pr));
 405       if (!select_pool_dbr(ua, &pr)) {
 406          return 1;
 407       }
 408    }
 409
 410    ok = send_label_request(ua, &mr, &omr, &pr, relabel, media_record_exists, drive);
 411
 412    if (ok) {
 413       sd = ua->jcr->store_bsock;
 414       if (relabel) {
 415          /* Delete the old media record */
 416          if (!db_delete_media_record(ua->jcr, ua->db, &omr)) {
 417             bsendmsg(ua, _("Delete of Volume \"%s\" failed. ERR=%s"),
 418                omr.VolumeName, db_strerror(ua->db));
 419          } else {
 420             bsendmsg(ua, _("Old volume \"%s\" deleted from catalog.\n"),
 421                omr.VolumeName);
 422             /* Update the number of Volumes in the pool */
 423             pr.NumVols--;
 424             if (!db_update_pool_record(ua->jcr, ua->db, &pr)) {
 425                bsendmsg(ua, "%s", db_strerror(ua->db));
 426             }
 427          }
 428       }
 429       if (ua->automount) {
 430          bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
 431          bsendmsg(ua, _("Requesting to mount %s ...\n"), dev_name);
 432          bash_spaces(dev_name);
 433          bnet_fsend(sd, "mount %s drive=%d", dev_name, drive);
 434          unbash_spaces(dev_name);
 435          while (bnet_recv(sd) >= 0) {
 436             bsendmsg(ua, "%s", sd->msg);
 437             /* Here we can get
 438              *  3001 OK mount. Device=xxx      or
 439              *  3001 Mounted Volume vvvv
 440              *  3002 Device "DVD-Writer" (/dev/hdc) is mounted.
 441              *  3906 is cannot mount non-tape
 442              * So for those, no need to print a reminder
 443              */
 444             if (strncmp(sd->msg, "3001 ", 5) == 0 ||
 445                 strncmp(sd->msg, "3002 ", 5) == 0 ||
 446                 strncmp(sd->msg, "3906 ", 5) == 0) {
 447                print_reminder = false;
 448             }
 449          }
 450       }
 451    }
 452    if (print_reminder) {
 453       bsendmsg(ua, _("Do not forget to mount the drive!!!\n"));
 454    }
 455    close_sd_bsock(ua);
 456
 457    return 1;
 458 }
 459
 460 /*
 461  * Request SD to send us the slot:barcodes, then wiffle
 462  *  through them all labeling them.
 463  */
 464 static void label_from_barcodes(UAContext *ua, int drive)
 465 {
 466    STORE *store = ua->jcr->wstore;
 467    POOL_DBR pr;
 468    MEDIA_DBR mr, omr;
 469    vol_list_t *vl, *vol_list = NULL;
 470    bool media_record_exists;
 471    char *slot_list;
 472    int max_slots;
 473
 474
 475    max_slots = get_num_slots_from_SD(ua);
 476    if (max_slots <= 0) {
 477       bsendmsg(ua, _("No slots in changer to scan.\n"));
 478       return;
 479    }
 480    slot_list = (char *)malloc(max_slots+1);
 481    if (!get_user_slot_list(ua, slot_list, max_slots)) {
 482       goto bail_out;
 483    }
 484
 485    vol_list = get_vol_list_from_SD(ua, false /*no scan*/);
 486
 487    if (!vol_list) {
 488       bsendmsg(ua, _("No Volumes found to label, or no barcodes.\n"));
 489       goto bail_out;
 490    }
 491
 492    /* Display list of Volumes and ask if he really wants to proceed */
 493    bsendmsg(ua, _("The following Volumes will be labeled:\n"
 494                   "Slot  Volume\n"
 495                   "==============\n"));
 496    for (vl=vol_list; vl; vl=vl->next) {
 497       if (!vl->VolName || !slot_list[vl->Slot]) {
 498          continue;
 499       }
 500       bsendmsg(ua, "%4d  %s\n", vl->Slot, vl->VolName);
 501    }
 502    if (!get_yesno(ua, _("Do you want to continue? (yes|no): ")) ||
 503        (ua->pint32_val == 0)) {
 504       goto bail_out;
 505    }
 506    /* Select a pool */
 507    memset(&pr, 0, sizeof(pr));
 508    if (!select_pool_dbr(ua, &pr)) {
 509       goto bail_out;
 510    }
 511    memset(&omr, 0, sizeof(omr));
 512
 513    /* Fire off the label requests */
 514    for (vl=vol_list; vl; vl=vl->next) {
 515       if (!vl->VolName || !slot_list[vl->Slot]) {
 516          continue;
 517       }
 518       memset(&mr, 0, sizeof(mr));
 519       bstrncpy(mr.VolumeName, vl->VolName, sizeof(mr.VolumeName));
 520       media_record_exists = false;
 521       if (db_get_media_record(ua->jcr, ua->db, &mr)) {
 522           if (mr.VolBytes != 0) {
 523              bsendmsg(ua, _("Media record for Slot %d Volume \"%s\" already exists.\n"),
 524                 vl->Slot, mr.VolumeName);
 525              mr.Slot = vl->Slot;
 526              mr.InChanger = 1;
 527              mr.StorageId = store->StorageId;
 528              if (!db_update_media_record(ua->jcr, ua->db, &mr)) {
 529                 bsendmsg(ua, _("Error setting InChanger: ERR=%s"), db_strerror(ua->db));
 530              }
 531              continue;
 532           }
 533           media_record_exists = true;
 534       }
 535       mr.InChanger = 1;
 536       mr.StorageId = store->StorageId;
 537       /*
 538        * Deal with creating cleaning tape here. Normal tapes created in
 539        *  send_label_request() below
 540        */
 541       if (is_cleaning_tape(ua, &mr, &pr)) {
 542          if (media_record_exists) {      /* we update it */
 543             mr.VolBytes = 1;
 544             bstrncpy(mr.VolStatus, "Cleaning", sizeof(mr.VolStatus));
 545             mr.MediaType[0] = 0;
 546             mr.StorageId = store->StorageId;
 547             if (!db_update_media_record(ua->jcr, ua->db, &mr)) {
 548                 bsendmsg(ua, "%s", db_strerror(ua->db));
 549             }
 550          } else {                        /* create the media record */
 551             if (pr.MaxVols > 0 && pr.NumVols >= pr.MaxVols) {
 552                bsendmsg(ua, _("Maximum pool Volumes=%d reached.\n"), pr.MaxVols);
 553                goto bail_out;
 554             }
 555             set_pool_dbr_defaults_in_media_dbr(&mr, &pr);
 556             bstrncpy(mr.VolStatus, "Cleaning", sizeof(mr.VolStatus));
 557             mr.MediaType[0] = 0;
 558             if (db_create_media_record(ua->jcr, ua->db, &mr)) {
 559                bsendmsg(ua, _("Catalog record for cleaning tape \"%s\" successfully created.\n"),
 560                   mr.VolumeName);
 561                pr.NumVols++;          /* this is a bit suspect */
 562                if (!db_update_pool_record(ua->jcr, ua->db, &pr)) {
 563                   bsendmsg(ua, "%s", db_strerror(ua->db));
 564                }
 565             } else {
 566                bsendmsg(ua, _("Catalog error on cleaning tape: %s"), db_strerror(ua->db));
 567             }
 568          }
 569          continue;                    /* done, go handle next volume */
 570       }
 571       bstrncpy(mr.MediaType, store->media_type, sizeof(mr.MediaType));
 572
 573       mr.Slot = vl->Slot;
 574       send_label_request(ua, &mr, &omr, &pr, 0, media_record_exists, drive);
 575    }
 576
 577
 578 bail_out:
 579    free(slot_list);
 580    free_vol_list(vol_list);
 581    close_sd_bsock(ua);
 582
 583    return;
 584 }
 585
 586 /*
 587  * Check if the Volume name has legal characters
 588  * If ua is non-NULL send the message
 589  */
 590 bool is_volume_name_legal(UAContext *ua, const char *name)
 591 {
 592    int len;
 593    const char *p;
 594    const char *accept = ":.-_";
 595
 596    /* Restrict the characters permitted in the Volume name */
 597    for (p=name; *p; p++) {
 598       if (B_ISALPHA(*p) || B_ISDIGIT(*p) || strchr(accept, (int)(*p))) {
 599          continue;
 600       }
 601       if (ua) {
 602          bsendmsg(ua, _("Illegal character \"%c\" in a volume name.\n"), *p);
 603       }
 604       return 0;
 605    }
 606    len = strlen(name);
 607    if (len >= MAX_NAME_LENGTH) {
 608       if (ua) {
 609          bsendmsg(ua, _("Volume name too long.\n"));
 610       }
 611       return 0;
 612    }
 613    if (len == 0) {
 614       if (ua) {
 615          bsendmsg(ua, _("Volume name must be at least one character long.\n"));
 616       }
 617       return 0;
 618    }
 619    return 1;
 620 }
 621
 622 /*
 623  * NOTE! This routine opens the SD socket but leaves it open
 624  */
 625 static bool send_label_request(UAContext *ua, MEDIA_DBR *mr, MEDIA_DBR *omr,
 626                                POOL_DBR *pr, int relabel, bool media_record_exists,
 627                                int drive)
 628 {
 629    BSOCK *sd;
 630    char dev_name[MAX_NAME_LENGTH];
 631    bool ok = false;
 632    bool is_dvd = false;
 633
 634    if (!(sd=open_sd_bsock(ua))) {
 635       return false;
 636    }
 637    bstrncpy(dev_name, ua->jcr->wstore->dev_name(), sizeof(dev_name));
 638    bash_spaces(dev_name);
 639    bash_spaces(mr->VolumeName);
 640    bash_spaces(mr->MediaType);
 641    bash_spaces(pr->Name);
 642    if (relabel) {
 643       bash_spaces(omr->VolumeName);
 644       bnet_fsend(sd, "relabel %s OldName=%s NewName=%s PoolName=%s "
 645                      "MediaType=%s Slot=%d drive=%d",
 646                  dev_name, omr->VolumeName, mr->VolumeName, pr->Name,
 647                  mr->MediaType, mr->Slot, drive);
 648       bsendmsg(ua, _("Sending relabel command from \"%s\" to \"%s\" ...\n"),
 649          omr->VolumeName, mr->VolumeName);
 650    } else {
 651       bnet_fsend(sd, "label %s VolumeName=%s PoolName=%s MediaType=%s "
 652                      "Slot=%d drive=%d",
 653                  dev_name, mr->VolumeName, pr->Name, mr->MediaType,
 654                  mr->Slot, drive);
 655       bsendmsg(ua, _("Sending label command for Volume \"%s\" Slot %d ...\n"),
 656          mr->VolumeName, mr->Slot);
 657       Dmsg6(100, "label %s VolumeName=%s PoolName=%s MediaType=%s Slot=%d drive=%d\n",
 658          dev_name, mr->VolumeName, pr->Name, mr->MediaType, mr->Slot, drive);
 659    }
 660
 661    while (bnet_recv(sd) >= 0) {
 662       bsendmsg(ua, "%s", sd->msg);
 663       if (strncmp(sd->msg, "3000 OK label.", 14) == 0) {
 664          ok = true;
 665       }
 666       if (strncmp(sd->msg, "3000 OK label. DVD=1 ", 21) == 0) {
 667          is_dvd = true;
 668       }
 669    }
 670    unbash_spaces(mr->VolumeName);
 671    unbash_spaces(mr->MediaType);
 672    unbash_spaces(pr->Name);
 673    mr->LabelDate = time(NULL);
 674    mr->set_label_date = true;
 675    if (is_dvd) {
 676       /* We know that a freshly labelled DVD has 1 VolParts */
 677       /* This does not apply to auto-labelled DVDs. */
 678       mr->VolParts = 1;
 679    }
 680    if (ok) {
 681       if (media_record_exists) {      /* we update it */
 682          mr->VolBytes = 1;
 683          mr->InChanger = 1;
 684          mr->StorageId = ua->jcr->wstore->StorageId;
 685          if (!db_update_media_record(ua->jcr, ua->db, mr)) {
 686              bsendmsg(ua, "%s", db_strerror(ua->db));
 687              ok = false;
 688          }
 689       } else {                        /* create the media record */
 690          set_pool_dbr_defaults_in_media_dbr(mr, pr);
 691          mr->VolBytes = 1;               /* flag indicating Volume labeled */
 692          mr->InChanger = 1;
 693          mr->StorageId = ua->jcr->wstore->StorageId;
 694          mr->Enabled = 1;
 695          if (db_create_media_record(ua->jcr, ua->db, mr)) {
 696             bsendmsg(ua, _("Catalog record for Volume \"%s\", Slot %d  successfully created.\n"),
 697             mr->VolumeName, mr->Slot);
 698             /* Update number of volumes in pool */
 699             pr->NumVols++;
 700             if (!db_update_pool_record(ua->jcr, ua->db, pr)) {
 701                bsendmsg(ua, "%s", db_strerror(ua->db));
 702             }
 703          } else {
 704             bsendmsg(ua, "%s", db_strerror(ua->db));
 705             ok = false;
 706          }
 707       }
 708    } else {
 709       bsendmsg(ua, _("Label command failed for Volume %s.\n"), mr->VolumeName);
 710    }
 711    return ok;
 712 }
 713
 714 static BSOCK *open_sd_bsock(UAContext *ua)
 715 {
 716    STORE *store = ua->jcr->wstore;
 717
 718    if (!ua->jcr->store_bsock) {
 719       bsendmsg(ua, _("Connecting to Storage daemon %s at %s:%d ...\n"),
 720          store->name(), store->address, store->SDport);
 721       if (!connect_to_storage_daemon(ua->jcr, 10, SDConnectTimeout, 1)) {
 722          bsendmsg(ua, _("Failed to connect to Storage daemon.\n"));
 723          return NULL;
 724       }
 725    }
 726    return ua->jcr->store_bsock;
 727 }
 728
 729 static void close_sd_bsock(UAContext *ua)
 730 {
 731    if (ua->jcr->store_bsock) {
 732       bnet_sig(ua->jcr->store_bsock, BNET_TERMINATE);
 733       bnet_close(ua->jcr->store_bsock);
 734       ua->jcr->store_bsock = NULL;
 735    }
 736 }
 737
 738 static char *get_volume_name_from_SD(UAContext *ua, int Slot, int drive)
 739 {
 740    STORE *store = ua->jcr->wstore;
 741    BSOCK *sd;
 742    char dev_name[MAX_NAME_LENGTH];
 743    char *VolName = NULL;
 744    int rtn_slot;
 745
 746    if (!(sd=open_sd_bsock(ua))) {
 747       bsendmsg(ua, _("Could not open SD socket.\n"));
 748       return NULL;
 749    }
 750    bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
 751    bash_spaces(dev_name);
 752    /* Ask for autochanger list of volumes */
 753    bnet_fsend(sd, NT_("readlabel %s Slot=%d drive=%d\n"), dev_name, Slot, drive);
 754    Dmsg1(100, "Sent: %s", sd->msg);
 755
 756    /* Get Volume name in this Slot */
 757    while (bnet_recv(sd) >= 0) {
 758       bsendmsg(ua, "%s", sd->msg);
 759       Dmsg1(100, "Got: %s", sd->msg);
 760       if (strncmp(sd->msg, NT_("3001 Volume="), 12) == 0) {
 761          VolName = (char *)malloc(sd->msglen);
 762          if (sscanf(sd->msg, NT_("3001 Volume=%s Slot=%d"), VolName, &rtn_slot) == 2) {
 763             break;
 764          }
 765          free(VolName);
 766          VolName = NULL;
 767       }
 768    }
 769    close_sd_bsock(ua);
 770    Dmsg1(100, "get_vol_name=%s\n", NPRT(VolName));
 771    return VolName;
 772 }
 773
 774 /*
 775  * We get the slot list from the Storage daemon.
 776  *  If scan is set, we return all slots found,
 777  *  otherwise, we return only slots with valid barcodes (Volume names)
 778  */
 779 static vol_list_t *get_vol_list_from_SD(UAContext *ua, bool scan)
 780 {
 781    STORE *store = ua->jcr->wstore;
 782    char dev_name[MAX_NAME_LENGTH];
 783    BSOCK *sd;
 784    vol_list_t *vl;
 785    vol_list_t *vol_list = NULL;
 786
 787
 788    if (!(sd=open_sd_bsock(ua))) {
 789       return NULL;
 790    }
 791
 792    bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
 793    bash_spaces(dev_name);
 794    /* Ask for autochanger list of volumes */
 795    bnet_fsend(sd, NT_("autochanger list %s \n"), dev_name);
 796
 797    /* Read and organize list of Volumes */
 798    while (bnet_recv(sd) >= 0) {
 799       char *p;
 800       int Slot;
 801       strip_trailing_junk(sd->msg);
 802
 803       /* Check for returned SD messages */
 804       if (sd->msg[0] == '3'     && B_ISDIGIT(sd->msg[1]) &&
 805           B_ISDIGIT(sd->msg[2]) && B_ISDIGIT(sd->msg[3]) &&
 806           sd->msg[4] == ' ') {
 807          bsendmsg(ua, "%s\n", sd->msg);   /* pass them on to user */
 808          continue;
 809       }
 810
 811       /* Validate Slot: if scanning, otherwise  Slot:Barcode */
 812       p = strchr(sd->msg, ':');
 813       if (scan && p) {
 814          /* Scanning -- require only valid slot */
 815          Slot = atoi(sd->msg);
 816          if (Slot <= 0) {
 817             p--;
 818             *p = ':';
 819             bsendmsg(ua, _("Invalid Slot number: %s\n"), sd->msg);
 820             continue;
 821          }
 822       } else {
 823          /* Not scanning */
 824          if (p && strlen(p) > 1) {
 825             *p++ = 0;
 826             if (!is_an_integer(sd->msg) || (Slot=atoi(sd->msg)) <= 0) {
 827                p--;
 828                *p = ':';
 829                bsendmsg(ua, _("Invalid Slot number: %s\n"), sd->msg);
 830                continue;
 831             }
 832          } else {
 833             continue;
 834          }
 835          if (!is_volume_name_legal(ua, p)) {
 836             p--;
 837             *p = ':';
 838             bsendmsg(ua, _("Invalid Volume name: %s\n"), sd->msg);
 839             continue;
 840          }
 841       }
 842
 843       /* Add Slot and VolumeName to list */
 844       vl = (vol_list_t *)malloc(sizeof(vol_list_t));
 845       vl->Slot = Slot;
 846       if (p) {
 847          if (*p == ':') {
 848             p++;                      /* skip separator */
 849          }
 850          vl->VolName = bstrdup(p);
 851       } else {
 852          vl->VolName = NULL;
 853       }
 854       Dmsg2(100, "Add slot=%d Vol=%s to SD list.\n", vl->Slot, NPRT(vl->VolName));
 855       if (!vol_list) {
 856          vl->next = vol_list;
 857          vol_list = vl;
 858       } else {
 859          /* Add new entry to end of list */
 860          for (vol_list_t *tvl=vol_list; tvl; tvl=tvl->next) {
 861             if (!tvl->next) {
 862                tvl->next = vl;
 863                vl->next = NULL;
 864                break;
 865             }
 866          }
 867       }
 868    }
 869    close_sd_bsock(ua);
 870    return vol_list;
 871 }
 872
 873 static void free_vol_list(vol_list_t *vol_list)
 874 {
 875    vol_list_t *vl;
 876
 877    /* Free list */
 878    for (vl=vol_list; vl; ) {
 879       vol_list_t *ovl;
 880       if (vl->VolName) {
 881          free(vl->VolName);
 882       }
 883       ovl = vl;
 884       vl = vl->next;
 885       free(ovl);
 886    }
 887 }
 888
 889 /*
 890  * We get the number of slots in the changer from the SD
 891  */
 892 static int get_num_slots_from_SD(UAContext *ua)
 893 {
 894    STORE *store = ua->jcr->wstore;
 895    char dev_name[MAX_NAME_LENGTH];
 896    BSOCK *sd;
 897    int slots = 0;
 898
 899
 900    if (!(sd=open_sd_bsock(ua))) {
 901       return 0;
 902    }
 903
 904    bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
 905    bash_spaces(dev_name);
 906    /* Ask for autochanger number of slots */
 907    bnet_fsend(sd, NT_("autochanger slots %s\n"), dev_name);
 908
 909    while (bnet_recv(sd) >= 0) {
 910       if (sscanf(sd->msg, "slots=%d\n", &slots) == 1) {
 911          break;
 912       } else {
 913          bsendmsg(ua, "%s", sd->msg);
 914       }
 915    }
 916    close_sd_bsock(ua);
 917    bsendmsg(ua, _("Device \"%s\" has %d slots.\n"), store->dev_name(), slots);
 918    return slots;
 919 }
 920
 921 /*
 922  * We get the number of drives in the changer from the SD
 923  */
 924 int get_num_drives_from_SD(UAContext *ua)
 925 {
 926    STORE *store = ua->jcr->wstore;
 927    char dev_name[MAX_NAME_LENGTH];
 928    BSOCK *sd;
 929    int drives = 0;
 930
 931
 932    if (!(sd=open_sd_bsock(ua))) {
 933       return 0;
 934    }
 935
 936    bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
 937    bash_spaces(dev_name);
 938    /* Ask for autochanger number of slots */
 939    bnet_fsend(sd, NT_("autochanger drives %s\n"), dev_name);
 940
 941    while (bnet_recv(sd) >= 0) {
 942       if (sscanf(sd->msg, NT_("drives=%d\n"), &drives) == 1) {
 943          break;
 944       } else {
 945          bsendmsg(ua, "%s", sd->msg);
 946       }
 947    }
 948    close_sd_bsock(ua);
 949 //   bsendmsg(ua, _("Device \"%s\" has %d drives.\n"), store->dev_name(), drives);
 950    return drives;
 951 }
 952
 953
 954
 955
 956 /*
 957  * Check if this is a cleaning tape by comparing the Volume name
 958  *  with the Cleaning Prefix. If they match, this is a cleaning
 959  *  tape.
 960  */
 961 static bool is_cleaning_tape(UAContext *ua, MEDIA_DBR *mr, POOL_DBR *pr)
 962 {
 963    /* Find Pool resource */
 964    ua->jcr->pool = (POOL *)GetResWithName(R_POOL, pr->Name);
 965    if (!ua->jcr->pool) {
 966       bsendmsg(ua, _("Pool \"%s\" resource not found for volume \"%s\"!\n"),
 967          pr->Name, mr->VolumeName);
 968       return false;
 969    }
 970    if (ua->jcr->pool->cleaning_prefix == NULL) {
 971       return false;
 972    }
 973    Dmsg4(100, "CLNprefix=%s: Vol=%s: len=%d strncmp=%d\n",
 974       ua->jcr->pool->cleaning_prefix, mr->VolumeName,
 975       strlen(ua->jcr->pool->cleaning_prefix),
 976       strncmp(mr->VolumeName, ua->jcr->pool->cleaning_prefix,
 977                   strlen(ua->jcr->pool->cleaning_prefix)));
 978    return strncmp(mr->VolumeName, ua->jcr->pool->cleaning_prefix,
 979                   strlen(ua->jcr->pool->cleaning_prefix)) == 0;
 980 }