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_storage(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_storage(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->store;
 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
 633    if (!(sd=open_sd_bsock(ua))) {
 634       return false;
 635    }
 636    bstrncpy(dev_name, ua->jcr->store->dev_name(), sizeof(dev_name));
 637    bash_spaces(dev_name);
 638    bash_spaces(mr->VolumeName);
 639    bash_spaces(mr->MediaType);
 640    bash_spaces(pr->Name);
 641    if (relabel) {
 642       bash_spaces(omr->VolumeName);
 643       bnet_fsend(sd, "relabel %s OldName=%s NewName=%s PoolName=%s "
 644                      "MediaType=%s Slot=%d drive=%d",
 645                  dev_name, omr->VolumeName, mr->VolumeName, pr->Name,
 646                  mr->MediaType, mr->Slot, drive);
 647       bsendmsg(ua, _("Sending relabel command from \"%s\" to \"%s\" ...\n"),
 648          omr->VolumeName, mr->VolumeName);
 649    } else {
 650       bnet_fsend(sd, "label %s VolumeName=%s PoolName=%s MediaType=%s "
 651                      "Slot=%d drive=%d",
 652                  dev_name, mr->VolumeName, pr->Name, mr->MediaType,
 653                  mr->Slot, drive);
 654       bsendmsg(ua, _("Sending label command for Volume \"%s\" Slot %d ...\n"),
 655          mr->VolumeName, mr->Slot);
 656       Dmsg6(100, "label %s VolumeName=%s PoolName=%s MediaType=%s Slot=%d drive=%d\n",
 657          dev_name, mr->VolumeName, pr->Name, mr->MediaType, mr->Slot, drive);
 658    }
 659
 660    while (bnet_recv(sd) >= 0) {
 661       bsendmsg(ua, "%s", sd->msg);
 662       if (strncmp(sd->msg, "3000 OK label.", 14) == 0) {
 663          ok = true;
 664       }
 665    }
 666    unbash_spaces(mr->VolumeName);
 667    unbash_spaces(mr->MediaType);
 668    unbash_spaces(pr->Name);
 669    mr->LabelDate = time(NULL);
 670    mr->set_label_date = true;
 671    if (ok) {
 672       if (media_record_exists) {      /* we update it */
 673          mr->VolBytes = 1;
 674          mr->InChanger = 1;
 675          mr->StorageId = ua->jcr->store->StorageId;
 676          if (!db_update_media_record(ua->jcr, ua->db, mr)) {
 677              bsendmsg(ua, "%s", db_strerror(ua->db));
 678              ok = false;
 679          }
 680       } else {                        /* create the media record */
 681          set_pool_dbr_defaults_in_media_dbr(mr, pr);
 682          mr->VolBytes = 1;               /* flag indicating Volume labeled */
 683          mr->InChanger = 1;
 684          mr->StorageId = ua->jcr->store->StorageId;
 685          if (db_create_media_record(ua->jcr, ua->db, mr)) {
 686             bsendmsg(ua, _("Catalog record for Volume \"%s\", Slot %d  successfully created.\n"),
 687             mr->VolumeName, mr->Slot);
 688             /* Update number of volumes in pool */
 689             pr->NumVols++;
 690             if (!db_update_pool_record(ua->jcr, ua->db, pr)) {
 691                bsendmsg(ua, "%s", db_strerror(ua->db));
 692             }
 693          } else {
 694             bsendmsg(ua, "%s", db_strerror(ua->db));
 695             ok = false;
 696          }
 697       }
 698    } else {
 699       bsendmsg(ua, _("Label command failed for Volume %s.\n"), mr->VolumeName);
 700    }
 701    return ok;
 702 }
 703
 704 static BSOCK *open_sd_bsock(UAContext *ua)
 705 {
 706    STORE *store = ua->jcr->store;
 707
 708    if (!ua->jcr->store_bsock) {
 709       bsendmsg(ua, _("Connecting to Storage daemon %s at %s:%d ...\n"),
 710          store->hdr.name, store->address, store->SDport);
 711       if (!connect_to_storage_daemon(ua->jcr, 10, SDConnectTimeout, 1)) {
 712          bsendmsg(ua, _("Failed to connect to Storage daemon.\n"));
 713          return NULL;
 714       }
 715    }
 716    return ua->jcr->store_bsock;
 717 }
 718
 719 static void close_sd_bsock(UAContext *ua)
 720 {
 721    if (ua->jcr->store_bsock) {
 722       bnet_sig(ua->jcr->store_bsock, BNET_TERMINATE);
 723       bnet_close(ua->jcr->store_bsock);
 724       ua->jcr->store_bsock = NULL;
 725    }
 726 }
 727
 728 static char *get_volume_name_from_SD(UAContext *ua, int Slot, int drive)
 729 {
 730    STORE *store = ua->jcr->store;
 731    BSOCK *sd;
 732    char dev_name[MAX_NAME_LENGTH];
 733    char *VolName = NULL;
 734    int rtn_slot;
 735
 736    if (!(sd=open_sd_bsock(ua))) {
 737       bsendmsg(ua, _("Could not open SD socket.\n"));
 738       return NULL;
 739    }
 740    bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
 741    bash_spaces(dev_name);
 742    /* Ask for autochanger list of volumes */
 743    bnet_fsend(sd, NT_("readlabel %s Slot=%d drive=%d\n"), dev_name, Slot, drive);
 744    Dmsg1(100, "Sent: %s", sd->msg);
 745
 746    /* Get Volume name in this Slot */
 747    while (bnet_recv(sd) >= 0) {
 748       bsendmsg(ua, "%s", sd->msg);
 749       Dmsg1(100, "Got: %s", sd->msg);
 750       if (strncmp(sd->msg, NT_("3001 Volume="), 12) == 0) {
 751          VolName = (char *)malloc(sd->msglen);
 752          if (sscanf(sd->msg, NT_("3001 Volume=%s Slot=%d"), VolName, &rtn_slot) == 2) {
 753             break;
 754          }
 755          free(VolName);
 756          VolName = NULL;
 757       }
 758    }
 759    close_sd_bsock(ua);
 760    Dmsg1(100, "get_vol_name=%s\n", NPRT(VolName));
 761    return VolName;
 762 }
 763
 764 /*
 765  * We get the slot list from the Storage daemon.
 766  *  If scan is set, we return all slots found,
 767  *  otherwise, we return only slots with valid barcodes (Volume names)
 768  */
 769 static vol_list_t *get_vol_list_from_SD(UAContext *ua, bool scan)
 770 {
 771    STORE *store = ua->jcr->store;
 772    char dev_name[MAX_NAME_LENGTH];
 773    BSOCK *sd;
 774    vol_list_t *vl;
 775    vol_list_t *vol_list = NULL;
 776
 777
 778    if (!(sd=open_sd_bsock(ua))) {
 779       return NULL;
 780    }
 781
 782    bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
 783    bash_spaces(dev_name);
 784    /* Ask for autochanger list of volumes */
 785    bnet_fsend(sd, NT_("autochanger list %s \n"), dev_name);
 786
 787    /* Read and organize list of Volumes */
 788    while (bnet_recv(sd) >= 0) {
 789       char *p;
 790       int Slot;
 791       strip_trailing_junk(sd->msg);
 792
 793       /* Check for returned SD messages */
 794       if (sd->msg[0] == '3'     && B_ISDIGIT(sd->msg[1]) &&
 795           B_ISDIGIT(sd->msg[2]) && B_ISDIGIT(sd->msg[3]) &&
 796           sd->msg[4] == ' ') {
 797          bsendmsg(ua, "%s\n", sd->msg);   /* pass them on to user */
 798          continue;
 799       }
 800
 801       /* Validate Slot: if scanning, otherwise  Slot:Barcode */
 802       p = strchr(sd->msg, ':');
 803       if (scan && p) {
 804          /* Scanning -- require only valid slot */
 805          Slot = atoi(sd->msg);
 806          if (Slot <= 0) {
 807             p--;
 808             *p = ':';
 809             bsendmsg(ua, _("Invalid Slot number: %s\n"), sd->msg);
 810             continue;
 811          }
 812       } else {
 813          /* Not scanning */
 814          if (p && strlen(p) > 1) {
 815             *p++ = 0;
 816             if (!is_an_integer(sd->msg) || (Slot=atoi(sd->msg)) <= 0) {
 817                p--;
 818                *p = ':';
 819                bsendmsg(ua, _("Invalid Slot number: %s\n"), sd->msg);
 820                continue;
 821             }
 822          } else {
 823             continue;
 824          }
 825          if (!is_volume_name_legal(ua, p)) {
 826             p--;
 827             *p = ':';
 828             bsendmsg(ua, _("Invalid Volume name: %s\n"), sd->msg);
 829             continue;
 830          }
 831       }
 832
 833       /* Add Slot and VolumeName to list */
 834       vl = (vol_list_t *)malloc(sizeof(vol_list_t));
 835       vl->Slot = Slot;
 836       if (p) {
 837          if (*p == ':') {
 838             p++;                      /* skip separator */
 839          }
 840          vl->VolName = bstrdup(p);
 841       } else {
 842          vl->VolName = NULL;
 843       }
 844       Dmsg2(100, "Add slot=%d Vol=%s to SD list.\n", vl->Slot, NPRT(vl->VolName));
 845       if (!vol_list) {
 846          vl->next = vol_list;
 847          vol_list = vl;
 848       } else {
 849          /* Add new entry to end of list */
 850          for (vol_list_t *tvl=vol_list; tvl; tvl=tvl->next) {
 851             if (!tvl->next) {
 852                tvl->next = vl;
 853                vl->next = NULL;
 854                break;
 855             }
 856          }
 857       }
 858    }
 859    close_sd_bsock(ua);
 860    return vol_list;
 861 }
 862
 863 static void free_vol_list(vol_list_t *vol_list)
 864 {
 865    vol_list_t *vl;
 866
 867    /* Free list */
 868    for (vl=vol_list; vl; ) {
 869       vol_list_t *ovl;
 870       if (vl->VolName) {
 871          free(vl->VolName);
 872       }
 873       ovl = vl;
 874       vl = vl->next;
 875       free(ovl);
 876    }
 877 }
 878
 879 /*
 880  * We get the number of slots in the changer from the SD
 881  */
 882 static int get_num_slots_from_SD(UAContext *ua)
 883 {
 884    STORE *store = ua->jcr->store;
 885    char dev_name[MAX_NAME_LENGTH];
 886    BSOCK *sd;
 887    int slots = 0;
 888
 889
 890    if (!(sd=open_sd_bsock(ua))) {
 891       return 0;
 892    }
 893
 894    bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
 895    bash_spaces(dev_name);
 896    /* Ask for autochanger number of slots */
 897    bnet_fsend(sd, NT_("autochanger slots %s\n"), dev_name);
 898
 899    while (bnet_recv(sd) >= 0) {
 900       if (sscanf(sd->msg, "slots=%d\n", &slots) == 1) {
 901          break;
 902       } else {
 903          bsendmsg(ua, "%s", sd->msg);
 904       }
 905    }
 906    close_sd_bsock(ua);
 907    bsendmsg(ua, _("Device \"%s\" has %d slots.\n"), store->dev_name(), slots);
 908    return slots;
 909 }
 910
 911 /*
 912  * We get the number of drives in the changer from the SD
 913  */
 914 int get_num_drives_from_SD(UAContext *ua)
 915 {
 916    STORE *store = ua->jcr->store;
 917    char dev_name[MAX_NAME_LENGTH];
 918    BSOCK *sd;
 919    int drives = 0;
 920
 921
 922    if (!(sd=open_sd_bsock(ua))) {
 923       return 0;
 924    }
 925
 926    bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
 927    bash_spaces(dev_name);
 928    /* Ask for autochanger number of slots */
 929    bnet_fsend(sd, NT_("autochanger drives %s\n"), dev_name);
 930
 931    while (bnet_recv(sd) >= 0) {
 932       if (sscanf(sd->msg, NT_("drives=%d\n"), &drives) == 1) {
 933          break;
 934       } else {
 935          bsendmsg(ua, "%s", sd->msg);
 936       }
 937    }
 938    close_sd_bsock(ua);
 939 //   bsendmsg(ua, _("Device \"%s\" has %d drives.\n"), store->dev_name(), drives);
 940    return drives;
 941 }
 942
 943
 944
 945
 946 /*
 947  * Check if this is a cleaning tape by comparing the Volume name
 948  *  with the Cleaning Prefix. If they match, this is a cleaning
 949  *  tape.
 950  */
 951 static bool is_cleaning_tape(UAContext *ua, MEDIA_DBR *mr, POOL_DBR *pr)
 952 {
 953    /* Find Pool resource */
 954    ua->jcr->pool = (POOL *)GetResWithName(R_POOL, pr->Name);
 955    if (!ua->jcr->pool) {
 956       bsendmsg(ua, _("Pool \"%s\" resource not found for volume \"%s\"!\n"),
 957          pr->Name, mr->VolumeName);
 958       return false;
 959    }
 960    if (ua->jcr->pool->cleaning_prefix == NULL) {
 961       return false;
 962    }
 963    Dmsg4(100, "CLNprefix=%s: Vol=%s: len=%d strncmp=%d\n",
 964       ua->jcr->pool->cleaning_prefix, mr->VolumeName,
 965       strlen(ua->jcr->pool->cleaning_prefix),
 966       strncmp(mr->VolumeName, ua->jcr->pool->cleaning_prefix,
 967                   strlen(ua->jcr->pool->cleaning_prefix)));
 968    return strncmp(mr->VolumeName, ua->jcr->pool->cleaning_prefix,
 969                   strlen(ua->jcr->pool->cleaning_prefix)) == 0;
 970 }