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

   1 /*
   2  *
   3  *   Bacula Director -- Update command processing
   4  *     Split from ua_cmds.c March 2005
   5  *
   6  *     Kern Sibbald, September MM
   7  *
   8  *   Version $Id$
   9  */
  10 /*
  11    Copyright (C) 2000-2006 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
  15    version 2 as amended with additional clauses defined in the
  16    file LICENSE in the main source directory.
  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
  21    the file LICENSE for additional details.
  22
  23  */
  24
  25 #include "bacula.h"
  26 #include "dird.h"
  27
  28 /* Imported functions */
  29 void update_slots(UAContext *ua);
  30
  31
  32
  33 /* Forward referenced functions */
  34 static int update_volume(UAContext *ua);
  35 static bool update_pool(UAContext *ua);
  36
  37 /*
  38  * Update a Pool Record in the database.
  39  *  It is always updated from the Resource record.
  40  *
  41  *    update pool=<pool-name>
  42  *         updates pool from Pool resource
  43  *    update media pool=<pool-name> volume=<volume-name>
  44  *         changes pool info for volume
  45  *    update slots [scan=...]
  46  *         updates autochanger slots
  47  */
  48 int update_cmd(UAContext *ua, const char *cmd)
  49 {
  50    static const char *kw[] = {
  51       NT_("media"),  /* 0 */
  52       NT_("volume"), /* 1 */
  53       NT_("pool"),   /* 2 */
  54       NT_("slots"),  /* 3 */
  55       NULL};
  56
  57    if (!open_db(ua)) {
  58       return 1;
  59    }
  60
  61    switch (find_arg_keyword(ua, kw)) {
  62    case 0:
  63    case 1:
  64       update_volume(ua);
  65       return 1;
  66    case 2:
  67       update_pool(ua);
  68       return 1;
  69    case 3:
  70       update_slots(ua);
  71       return 1;
  72    default:
  73       break;
  74    }
  75
  76    start_prompt(ua, _("Update choice:\n"));
  77    add_prompt(ua, _("Volume parameters"));
  78    add_prompt(ua, _("Pool from resource"));
  79    add_prompt(ua, _("Slots from autochanger"));
  80    switch (do_prompt(ua, _("item"), _("Choose catalog item to update"), NULL, 0)) {
  81    case 0:
  82       update_volume(ua);
  83       break;
  84    case 1:
  85       update_pool(ua);
  86       break;
  87    case 2:
  88       update_slots(ua);
  89       break;
  90    default:
  91       break;
  92    }
  93    return 1;
  94 }
  95
  96 static void update_volstatus(UAContext *ua, const char *val, MEDIA_DBR *mr)
  97 {
  98    POOL_MEM query(PM_MESSAGE);
  99    const char *kw[] = {
 100       NT_("Append"),
 101       NT_("Archive"),
 102       NT_("Disabled"),
 103       NT_("Full"),
 104       NT_("Used"),
 105       NT_("Cleaning"),
 106       NT_("Recycle"),
 107       NT_("Read-Only"),
 108       NULL};
 109    bool found = false;
 110    int i;
 111
 112    for (i=0; kw[i]; i++) {
 113       if (strcasecmp(val, kw[i]) == 0) {
 114          found = true;
 115          break;
 116       }
 117    }
 118    if (!found) {
 119       bsendmsg(ua, _("Invalid VolStatus specified: %s\n"), val);
 120    } else {
 121       char ed1[50];
 122       bstrncpy(mr->VolStatus, kw[i], sizeof(mr->VolStatus));
 123       Mmsg(query, "UPDATE Media SET VolStatus='%s' WHERE MediaId=%s",
 124          mr->VolStatus, edit_int64(mr->MediaId,ed1));
 125       if (!db_sql_query(ua->db, query.c_str(), NULL, NULL)) {
 126          bsendmsg(ua, "%s", db_strerror(ua->db));
 127       } else {
 128          bsendmsg(ua, _("New Volume status is: %s\n"), mr->VolStatus);
 129       }
 130    }
 131 }
 132
 133 static void update_volretention(UAContext *ua, char *val, MEDIA_DBR *mr)
 134 {
 135    char ed1[150], ed2[50];
 136    POOL_MEM query(PM_MESSAGE);
 137    if (!duration_to_utime(val, &mr->VolRetention)) {
 138       bsendmsg(ua, _("Invalid retention period specified: %s\n"), val);
 139       return;
 140    }
 141    Mmsg(query, "UPDATE Media SET VolRetention=%s WHERE MediaId=%s",
 142       edit_uint64(mr->VolRetention, ed1), edit_int64(mr->MediaId,ed2));
 143    if (!db_sql_query(ua->db, query.c_str(), NULL, NULL)) {
 144       bsendmsg(ua, "%s", db_strerror(ua->db));
 145    } else {
 146       bsendmsg(ua, _("New retention period is: %s\n"),
 147          edit_utime(mr->VolRetention, ed1, sizeof(ed1)));
 148    }
 149 }
 150
 151 static void update_voluseduration(UAContext *ua, char *val, MEDIA_DBR *mr)
 152 {
 153    char ed1[150], ed2[50];
 154    POOL_MEM query(PM_MESSAGE);
 155
 156    if (!duration_to_utime(val, &mr->VolUseDuration)) {
 157       bsendmsg(ua, _("Invalid use duration specified: %s\n"), val);
 158       return;
 159    }
 160    Mmsg(query, "UPDATE Media SET VolUseDuration=%s WHERE MediaId=%s",
 161       edit_uint64(mr->VolUseDuration, ed1), edit_int64(mr->MediaId,ed2));
 162    if (!db_sql_query(ua->db, query.c_str(), NULL, NULL)) {
 163       bsendmsg(ua, "%s", db_strerror(ua->db));
 164    } else {
 165       bsendmsg(ua, _("New use duration is: %s\n"),
 166          edit_utime(mr->VolUseDuration, ed1, sizeof(ed1)));
 167    }
 168 }
 169
 170 static void update_volmaxjobs(UAContext *ua, char *val, MEDIA_DBR *mr)
 171 {
 172    POOL_MEM query(PM_MESSAGE);
 173    char ed1[50];
 174    Mmsg(query, "UPDATE Media SET MaxVolJobs=%s WHERE MediaId=%s",
 175       val, edit_int64(mr->MediaId,ed1));
 176    if (!db_sql_query(ua->db, query.c_str(), NULL, NULL)) {
 177       bsendmsg(ua, "%s", db_strerror(ua->db));
 178    } else {
 179       bsendmsg(ua, _("New max jobs is: %s\n"), val);
 180    }
 181 }
 182
 183 static void update_volmaxfiles(UAContext *ua, char *val, MEDIA_DBR *mr)
 184 {
 185    POOL_MEM query(PM_MESSAGE);
 186    char ed1[50];
 187    Mmsg(query, "UPDATE Media SET MaxVolFiles=%s WHERE MediaId=%s",
 188       val, edit_int64(mr->MediaId, ed1));
 189    if (!db_sql_query(ua->db, query.c_str(), NULL, NULL)) {
 190       bsendmsg(ua, "%s", db_strerror(ua->db));
 191    } else {
 192       bsendmsg(ua, _("New max files is: %s\n"), val);
 193    }
 194 }
 195
 196 static void update_volmaxbytes(UAContext *ua, char *val, MEDIA_DBR *mr)
 197 {
 198    uint64_t maxbytes;
 199    char ed1[50], ed2[50];
 200    POOL_MEM query(PM_MESSAGE);
 201
 202    if (!size_to_uint64(val, strlen(val), &maxbytes)) {
 203       bsendmsg(ua, _("Invalid max. bytes specification: %s\n"), val);
 204       return;
 205    }
 206    Mmsg(query, "UPDATE Media SET MaxVolBytes=%s WHERE MediaId=%s",
 207       edit_uint64(maxbytes, ed1), edit_int64(mr->MediaId, ed2));
 208    if (!db_sql_query(ua->db, query.c_str(), NULL, NULL)) {
 209       bsendmsg(ua, "%s", db_strerror(ua->db));
 210    } else {
 211       bsendmsg(ua, _("New Max bytes is: %s\n"), edit_uint64(maxbytes, ed1));
 212    }
 213 }
 214
 215 static void update_volrecycle(UAContext *ua, char *val, MEDIA_DBR *mr)
 216 {
 217    int recycle;
 218    char ed1[50];
 219
 220    POOL_MEM query(PM_MESSAGE);
 221    if (!is_yesno(val, &recycle)) {
 222       bsendmsg(ua, _("Invalid value. It must be yes or no.\n"));
 223       return;
 224    }
 225    Mmsg(query, "UPDATE Media SET Recycle=%d WHERE MediaId=%s",
 226       recycle, edit_int64(mr->MediaId, ed1));
 227    if (!db_sql_query(ua->db, query.c_str(), NULL, NULL)) {
 228       bsendmsg(ua, "%s", db_strerror(ua->db));
 229    } else {
 230       bsendmsg(ua, _("New Recycle flag is: %s\n"),
 231          mr->Recycle==1?_("yes"):_("no"));
 232    }
 233 }
 234
 235 static void update_volinchanger(UAContext *ua, char *val, MEDIA_DBR *mr)
 236 {
 237    int InChanger;
 238    char ed1[50];
 239
 240    POOL_MEM query(PM_MESSAGE);
 241    if (!is_yesno(val, &InChanger)) {
 242       bsendmsg(ua, _("Invalid value. It must be yes or no.\n"));
 243       return;
 244    }
 245    Mmsg(query, "UPDATE Media SET InChanger=%d WHERE MediaId=%s",
 246       InChanger, edit_int64(mr->MediaId, ed1));
 247    if (!db_sql_query(ua->db, query.c_str(), NULL, NULL)) {
 248       bsendmsg(ua, "%s", db_strerror(ua->db));
 249    } else {
 250       bsendmsg(ua, _("New InChanger flag is: %s\n"),
 251          mr->InChanger==1?_("yes"):_("no"));
 252    }
 253 }
 254
 255
 256 static void update_volslot(UAContext *ua, char *val, MEDIA_DBR *mr)
 257 {
 258    POOL_DBR pr;
 259
 260    memset(&pr, 0, sizeof(POOL_DBR));
 261    pr.PoolId = mr->PoolId;
 262    if (!db_get_pool_record(ua->jcr, ua->db, &pr)) {
 263       bsendmsg(ua, "%s", db_strerror(ua->db));
 264       return;
 265    }
 266    mr->Slot = atoi(val);
 267    if (pr.MaxVols > 0 && mr->Slot > (int)pr.MaxVols) {
 268       bsendmsg(ua, _("Invalid slot, it must be between 0 and MaxVols=%d\n"),
 269          pr.MaxVols);
 270       return;
 271    }
 272    /*
 273     * Make sure to use db_update... rather than doing this directly,
 274     *   so that any Slot is handled correctly.
 275     */
 276    if (!db_update_media_record(ua->jcr, ua->db, mr)) {
 277       bsendmsg(ua, _("Error updating media record Slot: ERR=%s"), db_strerror(ua->db));
 278    } else {
 279       bsendmsg(ua, _("New Slot is: %d\n"), mr->Slot);
 280    }
 281 }
 282
 283 /* Modify the Pool in which this Volume is located */
 284 static void update_vol_pool(UAContext *ua, char *val, MEDIA_DBR *mr, POOL_DBR *opr)
 285 {
 286    POOL_DBR pr;
 287    POOLMEM *query;
 288    char ed1[50], ed2[50];
 289
 290    memset(&pr, 0, sizeof(pr));
 291    bstrncpy(pr.Name, val, sizeof(pr.Name));
 292    if (!get_pool_dbr(ua, &pr)) {
 293       return;
 294    }
 295    mr->PoolId = pr.PoolId;            /* set new PoolId */
 296    /*
 297     */
 298    query = get_pool_memory(PM_MESSAGE);
 299    db_lock(ua->db);
 300    Mmsg(query, "UPDATE Media SET PoolId=%s WHERE MediaId=%s",
 301       edit_int64(mr->PoolId, ed1),
 302       edit_int64(mr->MediaId, ed2));
 303    if (!db_sql_query(ua->db, query, NULL, NULL)) {
 304       bsendmsg(ua, "%s", db_strerror(ua->db));
 305    } else {
 306       bsendmsg(ua, _("New Pool is: %s\n"), pr.Name);
 307       opr->NumVols--;
 308       if (!db_update_pool_record(ua->jcr, ua->db, opr)) {
 309          bsendmsg(ua, "%s", db_strerror(ua->db));
 310       }
 311       pr.NumVols++;
 312       if (!db_update_pool_record(ua->jcr, ua->db, &pr)) {
 313          bsendmsg(ua, "%s", db_strerror(ua->db));
 314       }
 315    }
 316    db_unlock(ua->db);
 317    free_pool_memory(query);
 318 }
 319
 320 /*
 321  * Refresh the Volume information from the Pool record
 322  */
 323 static void update_vol_from_pool(UAContext *ua, MEDIA_DBR *mr)
 324 {
 325    POOL_DBR pr;
 326
 327    memset(&pr, 0, sizeof(pr));
 328    pr.PoolId = mr->PoolId;
 329    if (!db_get_pool_record(ua->jcr, ua->db, &pr) ||
 330        !acl_access_ok(ua, Pool_ACL, pr.Name)) {
 331       return;
 332    }
 333    set_pool_dbr_defaults_in_media_dbr(mr, &pr);
 334    if (!db_update_media_defaults(ua->jcr, ua->db, mr)) {
 335       bsendmsg(ua, _("Error updating Volume record: ERR=%s"), db_strerror(ua->db));
 336    } else {
 337       bsendmsg(ua, _("Volume defaults updated from \"%s\" Pool record.\n"),
 338          pr.Name);
 339    }
 340 }
 341
 342 /*
 343  * Refresh the Volume information from the Pool record
 344  *   for all Volumes
 345  */
 346 static void update_all_vols_from_pool(UAContext *ua)
 347 {
 348    POOL_DBR pr;
 349    MEDIA_DBR mr;
 350
 351    memset(&pr, 0, sizeof(pr));
 352    memset(&mr, 0, sizeof(mr));
 353    if (!get_pool_dbr(ua, &pr)) {
 354       return;
 355    }
 356    set_pool_dbr_defaults_in_media_dbr(&mr, &pr);
 357    mr.PoolId = pr.PoolId;
 358    if (!db_update_media_defaults(ua->jcr, ua->db, &mr)) {
 359       bsendmsg(ua, _("Error updating Volume records: ERR=%s"), db_strerror(ua->db));
 360    } else {
 361       bsendmsg(ua, _("All Volume defaults updated from Pool record.\n"));
 362    }
 363 }
 364
 365 static void update_volenabled(UAContext *ua, char *val, MEDIA_DBR *mr)
 366 {
 367    if (strcasecmp(val, "yes") == 0 || strcasecmp(val, "true") == 0) {
 368       mr->Enabled = 1;
 369    } else if (strcasecmp(val, "no") == 0 || strcasecmp(val, "false") == 0) {
 370       mr->Enabled = 0;
 371    } else if (strcasecmp(val, "archived") == 0) {
 372       mr->Enabled = 2;
 373    } else {
 374       mr->Enabled = atoi(val);
 375    }
 376    if (mr->Enabled < 0 || mr->Enabled > 2) {
 377       bsendmsg(ua, _("Invalid Enabled, it must be 0, 1, or 2\n"));
 378       return;
 379    }
 380    if (!db_update_media_record(ua->jcr, ua->db, mr)) {
 381       bsendmsg(ua, _("Error updating media record Enabled: ERR=%s"), db_strerror(ua->db));
 382    } else {
 383       bsendmsg(ua, _("New Enabled is: %d\n"), mr->Enabled);
 384    }
 385 }
 386
 387
 388
 389 /*
 390  * Update a media record -- allows you to change the
 391  *  Volume status. E.g. if you want Bacula to stop
 392  *  writing on the volume, set it to anything other
 393  *  than Append.
 394  */
 395 static int update_volume(UAContext *ua)
 396 {
 397    MEDIA_DBR mr;
 398    POOL_DBR pr;
 399    POOLMEM *query;
 400    char ed1[130];
 401    bool done = false;
 402    int i;
 403    const char *kw[] = {
 404       _("VolStatus"),                /* 0 */
 405       _("VolRetention"),             /* 1 */
 406       _("VolUse"),                   /* 2 */
 407       _("MaxVolJobs"),               /* 3 */
 408       _("MaxVolFiles"),              /* 4 */
 409       _("MaxVolBytes"),              /* 5 */
 410       _("Recycle"),                  /* 6 */
 411       _("InChanger"),                /* 7 */
 412       _("Slot"),                     /* 8 */
 413       _("Pool"),                     /* 9 */
 414       _("FromPool"),                 /* 10 */
 415       _("AllFromPool"),              /* 11 !!! see below !!! */
 416       _("Enabled"),                  /* 12 */
 417       NULL };
 418
 419 #define AllFromPool 11               /* keep this updated with above */
 420
 421    for (i=0; kw[i]; i++) {
 422       int j;
 423       POOL_DBR pr;
 424       if ((j=find_arg_with_value(ua, kw[i])) > 0) {
 425          /* If all from pool don't select a media record */
 426          if (i != AllFromPool && !select_media_dbr(ua, &mr)) {
 427             return 0;
 428          }
 429          switch (i) {
 430          case 0:
 431             update_volstatus(ua, ua->argv[j], &mr);
 432             break;
 433          case 1:
 434             update_volretention(ua, ua->argv[j], &mr);
 435             break;
 436          case 2:
 437             update_voluseduration(ua, ua->argv[j], &mr);
 438             break;
 439          case 3:
 440             update_volmaxjobs(ua, ua->argv[j], &mr);
 441             break;
 442          case 4:
 443             update_volmaxfiles(ua, ua->argv[j], &mr);
 444             break;
 445          case 5:
 446             update_volmaxbytes(ua, ua->argv[j], &mr);
 447             break;
 448          case 6:
 449             update_volrecycle(ua, ua->argv[j], &mr);
 450             break;
 451          case 7:
 452             update_volinchanger(ua, ua->argv[j], &mr);
 453             break;
 454          case 8:
 455             update_volslot(ua, ua->argv[j], &mr);
 456             break;
 457          case 9:
 458             memset(&pr, 0, sizeof(POOL_DBR));
 459             pr.PoolId = mr.PoolId;
 460             if (!db_get_pool_record(ua->jcr, ua->db, &pr)) {
 461                bsendmsg(ua, "%s", db_strerror(ua->db));
 462                break;
 463             }
 464             update_vol_pool(ua, ua->argv[j], &mr, &pr);
 465             break;
 466          case 10:
 467             update_vol_from_pool(ua, &mr);
 468             return 1;
 469          case 11:
 470             update_all_vols_from_pool(ua);
 471             return 1;
 472          case 12:
 473             update_volenabled(ua, ua->argv[j], &mr);
 474             break;
 475          }
 476          done = true;
 477       }
 478    }
 479
 480    for ( ; !done; ) {
 481       start_prompt(ua, _("Parameters to modify:\n"));
 482       add_prompt(ua, _("Volume Status"));              /* 0 */
 483       add_prompt(ua, _("Volume Retention Period"));    /* 1 */
 484       add_prompt(ua, _("Volume Use Duration"));        /* 2 */
 485       add_prompt(ua, _("Maximum Volume Jobs"));        /* 3 */
 486       add_prompt(ua, _("Maximum Volume Files"));       /* 4 */
 487       add_prompt(ua, _("Maximum Volume Bytes"));       /* 5 */
 488       add_prompt(ua, _("Recycle Flag"));               /* 6 */
 489       add_prompt(ua, _("Slot"));                       /* 7 */
 490       add_prompt(ua, _("InChanger Flag"));             /* 8 */
 491       add_prompt(ua, _("Volume Files"));               /* 9 */
 492       add_prompt(ua, _("Pool"));                       /* 10 */
 493       add_prompt(ua, _("Volume from Pool"));           /* 11 */
 494       add_prompt(ua, _("All Volumes from Pool"));      /* 12 */
 495       add_prompt(ua, _("Enabled")),                    /* 13 */
 496       add_prompt(ua, _("Done"));                       /* 14 */
 497       i = do_prompt(ua, "", _("Select parameter to modify"), NULL, 0);
 498
 499       /* For All Volumes from Pool and Done, we don't need a Volume record */
 500       if (i != 12 && i != 14) {
 501          if (!select_media_dbr(ua, &mr)) {  /* Get Volume record */
 502             return 0;
 503          }
 504          bsendmsg(ua, _("Updating Volume \"%s\"\n"), mr.VolumeName);
 505       }
 506       switch (i) {
 507       case 0:                         /* Volume Status */
 508          /* Modify Volume Status */
 509          bsendmsg(ua, _("Current Volume status is: %s\n"), mr.VolStatus);
 510          start_prompt(ua, _("Possible Values are:\n"));
 511          add_prompt(ua, NT_("Append"));
 512          add_prompt(ua, NT_("Archive"));
 513          add_prompt(ua, NT_("Disabled"));
 514          add_prompt(ua, NT_("Full"));
 515          add_prompt(ua, NT_("Used"));
 516          add_prompt(ua, NT_("Cleaning"));
 517          if (strcmp(mr.VolStatus, NT_("Purged")) == 0) {
 518             add_prompt(ua, NT_("Recycle"));
 519          }
 520          add_prompt(ua, NT_("Read-Only"));
 521          if (do_prompt(ua, "", _("Choose new Volume Status"), ua->cmd, sizeof(mr.VolStatus)) < 0) {
 522             return 1;
 523          }
 524          update_volstatus(ua, ua->cmd, &mr);
 525          break;
 526       case 1:                         /* Retention */
 527          bsendmsg(ua, _("Current retention period is: %s\n"),
 528             edit_utime(mr.VolRetention, ed1, sizeof(ed1)));
 529          if (!get_cmd(ua, _("Enter Volume Retention period: "))) {
 530             return 0;
 531          }
 532          update_volretention(ua, ua->cmd, &mr);
 533          break;
 534
 535       case 2:                         /* Use Duration */
 536          bsendmsg(ua, _("Current use duration is: %s\n"),
 537             edit_utime(mr.VolUseDuration, ed1, sizeof(ed1)));
 538          if (!get_cmd(ua, _("Enter Volume Use Duration: "))) {
 539             return 0;
 540          }
 541          update_voluseduration(ua, ua->cmd, &mr);
 542          break;
 543
 544       case 3:                         /* Max Jobs */
 545          bsendmsg(ua, _("Current max jobs is: %u\n"), mr.MaxVolJobs);
 546          if (!get_pint(ua, _("Enter new Maximum Jobs: "))) {
 547             return 0;
 548          }
 549          update_volmaxjobs(ua, ua->cmd, &mr);
 550          break;
 551
 552       case 4:                         /* Max Files */
 553          bsendmsg(ua, _("Current max files is: %u\n"), mr.MaxVolFiles);
 554          if (!get_pint(ua, _("Enter new Maximum Files: "))) {
 555             return 0;
 556          }
 557          update_volmaxfiles(ua, ua->cmd, &mr);
 558          break;
 559
 560       case 5:                         /* Max Bytes */
 561          bsendmsg(ua, _("Current value is: %s\n"), edit_uint64(mr.MaxVolBytes, ed1));
 562          if (!get_cmd(ua, _("Enter new Maximum Bytes: "))) {
 563             return 0;
 564          }
 565          update_volmaxbytes(ua, ua->cmd, &mr);
 566          break;
 567
 568
 569       case 6:                         /* Recycle */
 570          bsendmsg(ua, _("Current recycle flag is: %s\n"),
 571             mr.Recycle==1?_("yes"):_("no"));
 572          if (!get_yesno(ua, _("Enter new Recycle status: "))) {
 573             return 0;
 574          }
 575          update_volrecycle(ua, ua->cmd, &mr);
 576          break;
 577
 578       case 7:                         /* Slot */
 579          bsendmsg(ua, _("Current Slot is: %d\n"), mr.Slot);
 580          if (!get_pint(ua, _("Enter new Slot: "))) {
 581             return 0;
 582          }
 583          update_volslot(ua, ua->cmd, &mr);
 584          break;
 585
 586       case 8:                         /* InChanger */
 587          bsendmsg(ua, _("Current InChanger flag is: %d\n"), mr.InChanger);
 588          if (!get_yesno(ua, _("Set InChanger flag? yes/no: "))) {
 589             return 0;
 590          }
 591          mr.InChanger = ua->pint32_val;
 592          /*
 593           * Make sure to use db_update... rather than doing this directly,
 594           *   so that any Slot is handled correctly.
 595           */
 596          if (!db_update_media_record(ua->jcr, ua->db, &mr)) {
 597             bsendmsg(ua, _("Error updating media record Slot: ERR=%s"), db_strerror(ua->db));
 598          } else {
 599             bsendmsg(ua, _("New InChanger flag is: %d\n"), mr.InChanger);
 600          }
 601          break;
 602
 603
 604       case 9:                         /* Volume Files */
 605          int32_t VolFiles;
 606          bsendmsg(ua, _("Warning changing Volume Files can result\n"
 607                         "in loss of data on your Volume\n\n"));
 608          bsendmsg(ua, _("Current Volume Files is: %u\n"), mr.VolFiles);
 609          if (!get_pint(ua, _("Enter new number of Files for Volume: "))) {
 610             return 0;
 611          }
 612          VolFiles = ua->pint32_val;
 613          if (VolFiles != (int)(mr.VolFiles + 1)) {
 614             bsendmsg(ua, _("Normally, you should only increase Volume Files by one!\n"));
 615             if (!get_yesno(ua, _("Continue? (yes/no): ")) || ua->pint32_val == 0) {
 616                break;
 617             }
 618          }
 619          query = get_pool_memory(PM_MESSAGE);
 620          Mmsg(query, "UPDATE Media SET VolFiles=%u WHERE MediaId=%s",
 621             VolFiles, edit_int64(mr.MediaId, ed1));
 622          if (!db_sql_query(ua->db, query, NULL, NULL)) {
 623             bsendmsg(ua, "%s", db_strerror(ua->db));
 624          } else {
 625             bsendmsg(ua, _("New Volume Files is: %u\n"), VolFiles);
 626          }
 627          free_pool_memory(query);
 628          break;
 629
 630       case 10:                        /* Volume's Pool */
 631          memset(&pr, 0, sizeof(POOL_DBR));
 632          pr.PoolId = mr.PoolId;
 633          if (!db_get_pool_record(ua->jcr, ua->db, &pr)) {
 634             bsendmsg(ua, "%s", db_strerror(ua->db));
 635             return 0;
 636          }
 637          bsendmsg(ua, _("Current Pool is: %s\n"), pr.Name);
 638          if (!get_cmd(ua, _("Enter new Pool name: "))) {
 639             return 0;
 640          }
 641          update_vol_pool(ua, ua->cmd, &mr, &pr);
 642          return 1;
 643
 644       case 11:
 645          update_vol_from_pool(ua, &mr);
 646          return 1;
 647       case 12:
 648          update_all_vols_from_pool(ua);
 649          return 1;
 650
 651       case 13:
 652          bsendmsg(ua, _("Current Enabled is: %d\n"), mr.Enabled);
 653          if (!get_cmd(ua, _("Enter new Enabled: "))) {
 654             return 0;
 655          }
 656          if (strcasecmp(ua->cmd, "yes") == 0 || strcasecmp(ua->cmd, "true") == 0) {
 657             mr.Enabled = 1;
 658          } else if (strcasecmp(ua->cmd, "no") == 0 || strcasecmp(ua->cmd, "false") == 0) {
 659             mr.Enabled = 0;
 660          } else if (strcasecmp(ua->cmd, "archived") == 0) {
 661             mr.Enabled = 2;
 662          } else {
 663             mr.Enabled = atoi(ua->cmd);
 664          }
 665          update_volenabled(ua, ua->cmd, &mr);
 666          break;
 667
 668       default:                        /* Done or error */
 669          bsendmsg(ua, _("Selection terminated.\n"));
 670          return 1;
 671       }
 672    }
 673    return 1;
 674 }
 675
 676 /*
 677  * Update pool record -- pull info from current POOL resource
 678  */
 679 static bool update_pool(UAContext *ua)
 680 {
 681    POOL_DBR  pr;
 682    int id;
 683    POOL *pool;
 684    POOLMEM *query;
 685    char ed1[50];
 686
 687    pool = get_pool_resource(ua);
 688    if (!pool) {
 689       return false;
 690    }
 691
 692    memset(&pr, 0, sizeof(pr));
 693    bstrncpy(pr.Name, pool->hdr.name, sizeof(pr.Name));
 694    if (!get_pool_dbr(ua, &pr)) {
 695       return false;
 696    }
 697
 698    set_pooldbr_from_poolres(&pr, pool, POOL_OP_UPDATE); /* update */
 699
 700    id = db_update_pool_record(ua->jcr, ua->db, &pr);
 701    if (id <= 0) {
 702       bsendmsg(ua, _("db_update_pool_record returned %d. ERR=%s\n"),
 703          id, db_strerror(ua->db));
 704    }
 705    query = get_pool_memory(PM_MESSAGE);
 706    Mmsg(query, list_pool, edit_int64(pr.PoolId, ed1));
 707    db_list_sql_query(ua->jcr, ua->db, query, prtit, ua, 1, HORZ_LIST);
 708    free_pool_memory(query);
 709    bsendmsg(ua, _("Pool DB record updated from resource.\n"));
 710    return true;
 711 }