X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Fautochanger.c;h=792dfe3bcb9f91ff4344b8566fdc214b6f1a42ca;hb=f64919cdac2e8ca17d4db3a7fb5dcf774788d200;hp=f7b9619bcc4b1ed4b13f9c22628e88c9dbe66d3e;hpb=f0a7af9afe0811cf10d4efde51d337c05a2bba10;p=bacula%2Fbacula diff --git a/bacula/src/stored/autochanger.c b/bacula/src/stored/autochanger.c index f7b9619bcc..792dfe3bcb 100644 --- a/bacula/src/stored/autochanger.c +++ b/bacula/src/stored/autochanger.c @@ -1,3 +1,30 @@ +/* + Bacula® - The Network Backup Solution + + Copyright (C) 2002-2008 Free Software Foundation Europe e.V. + + The main author of Bacula is Kern Sibbald, with contributions from + many others, a complete list can be found in the file AUTHORS. + This program is Free Software; you can redistribute it and/or + modify it under the terms of version two of the GNU General Public + License as published by the Free Software Foundation and included + in the file LICENSE. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. + + Bacula® is a registered trademark of Kern Sibbald. + The licensor of Bacula is the Free Software Foundation Europe + (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich, + Switzerland, email:ftf@fsfeurope.org. +*/ /* * * Routines for handling the autochanger. @@ -6,20 +33,6 @@ * * Version $Id$ */ -/* - Copyright (C) 2002-2005 Kern Sibbald - - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License - version 2 as amended with additional clauses defined in the - file LICENSE in the main source directory. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - the file LICENSE for additional details. - - */ #include "bacula.h" /* pull in global headers */ #include "stored.h" /* pull in Storage Deamon headers */ @@ -27,6 +40,59 @@ /* Forward referenced functions */ static void lock_changer(DCR *dcr); static void unlock_changer(DCR *dcr); +static bool unload_other_drive(DCR *dcr, int slot); + +/* Init all the autochanger resources found */ +bool init_autochangers() +{ + bool OK = true; + AUTOCHANGER *changer; + /* Ensure that the media_type for each device is the same */ + foreach_res(changer, R_AUTOCHANGER) { + DEVRES *device; + foreach_alist(device, changer->device) { + /* + * If the device does not have a changer name or changer command + * defined, used the one from the Autochanger resource + */ + if (!device->changer_name && changer->changer_name) { + device->changer_name = bstrdup(changer->changer_name); + } + if (!device->changer_command && changer->changer_command) { + device->changer_command = bstrdup(changer->changer_command); + } + if (!device->changer_name) { + Jmsg(NULL, M_ERROR, 0, + _("No Changer Name given for device %s. Cannot continue.\n"), + device->hdr.name); + OK = false; + } + if (!device->changer_command) { + Jmsg(NULL, M_ERROR, 0, + _("No Changer Command given for device %s. Cannot continue.\n"), + device->hdr.name); + OK = false; + } + +#ifdef xxx_needed + if (media_type == NULL) { + media_type = device->media_type; /* get Media Type of first device */ + continue; + } + /* Ensure that other devices Media Types are the same */ + if (strcmp(media_type, device->media_type) != 0) { + Jmsg(NULL, M_ERROR, 0, + _("Media Type not the same for all devices in changer %s. Cannot continue.\n"), + changer->hdr.name); + OK = false; + continue; + } +#endif + } + } + return OK; +} + /* * Called here to do an autoload using the autochanger, if @@ -45,21 +111,35 @@ static void unlock_changer(DCR *dcr); int autoload_device(DCR *dcr, int writing, BSOCK *dir) { JCR *jcr = dcr->jcr; - DEVICE *dev = dcr->dev; + DEVICE * volatile dev = dcr->dev; int slot; - int drive = dev->device->drive_index; + int drive = dev->drive_index; int rtn_stat = -1; /* error status */ POOLMEM *changer; + if (!dev->is_autochanger()) { + Dmsg1(100, "Device %s is not an autochanger\n", dev->print_name()); + return 0; + } + + /* An empty ChangerCommand => virtual disk autochanger */ + if (dcr->device->changer_command && dcr->device->changer_command[0] == 0) { + Dmsg0(100, "ChangerCommand=0, virtual disk changer\n"); + return 1; /* nothing to load */ + } + slot = dcr->VolCatInfo.InChanger ? dcr->VolCatInfo.Slot : 0; + Dmsg3(100, "autoload: slot=%d InChgr=%d Vol=%s\n", dcr->VolCatInfo.Slot, + dcr->VolCatInfo.InChanger, dcr->VolCatInfo.VolCatName); /* * Handle autoloaders here. If we cannot autoload it, we * will return 0 so that the sysop will be asked to load it. */ - if (writing && dev->is_autochanger() && slot <= 0) { + if (writing && slot <= 0) { if (dir) { return 0; /* For user, bail out right now */ } + /* ***FIXME*** this really should not be here */ if (dir_find_next_appendable_volume(dcr)) { slot = dcr->VolCatInfo.InChanger ? dcr->VolCatInfo.Slot : 0; } else { @@ -69,79 +149,85 @@ int autoload_device(DCR *dcr, int writing, BSOCK *dir) Dmsg1(400, "Want changer slot=%d\n", slot); changer = get_pool_memory(PM_FNAME); - if (slot > 0 && dcr->device->changer_name && dcr->device->changer_command) { + if (slot <= 0) { + Jmsg(jcr, M_INFO, 0, _("Invalid slot=%d defined in catalog for Volume \"%s\" " + "on %s. Manual load may be required.\n"), slot, dcr->VolCatInfo.VolCatName, + dev->print_name()); + rtn_stat = 0; + } else if (!dcr->device->changer_name) { + Jmsg(jcr, M_INFO, 0, _("No \"Changer Device\" for %s. Manual load of Volume may be required.\n"), + dev->print_name()); + rtn_stat = 0; + } else if (!dcr->device->changer_command) { + Jmsg(jcr, M_INFO, 0, _("No \"Changer Command\" for %s. Manual load of Volume may be requird.\n"), + dev->print_name()); + rtn_stat = 0; + } else { + /* Attempt to load the Volume */ + uint32_t timeout = dcr->device->max_changer_wait; int loaded, status; loaded = get_autochanger_loaded_slot(dcr); - /* If tape we want is not loaded, load it. */ if (loaded != slot) { - offline_or_rewind_dev(dev); - /* We are going to load a new tape, so close the device */ - force_close_device(dev); - lock_changer(dcr); - if (loaded != 0 && loaded != -1) { /* must unload drive */ - Dmsg0(400, "Doing changer unload.\n"); - Jmsg(jcr, M_INFO, 0, - _("3303 Issuing autochanger \"unload slot %d, drive %d\" command.\n"), - loaded, drive); - dcr->VolCatInfo.Slot = loaded; /* slot to be unloaded */ - changer = edit_device_codes(dcr, changer, - dcr->device->changer_command, "unload"); - status = run_program(changer, timeout, NULL); - if (status != 0) { - berrno be; - be.set_errno(status); - Jmsg(jcr, M_FATAL, 0, _("3992 Bad autochanger \"unload slot %d, drive %d\": ERR=%s.\n"), - slot, drive, be.strerror()); - goto bail_out; - } else { - dev->Slot = 0; /* nothing loaded now */ - } - Dmsg1(400, "unload status=%d\n", status); + POOL_MEM results(PM_MESSAGE); + + /* Unload anything in our drive */ + if (!unload_autochanger(dcr, loaded)) { + goto bail_out; } + + /* Make sure desired slot is unloaded */ + if (!unload_other_drive(dcr, slot)) { + goto bail_out; + } + /* * Load the desired cassette */ - Dmsg1(400, "Doing changer load slot %d\n", slot); + lock_changer(dcr); + Dmsg2(100, "Doing changer load slot %d %s\n", slot, dev->print_name()); Jmsg(jcr, M_INFO, 0, _("3304 Issuing autochanger \"load slot %d, drive %d\" command.\n"), slot, drive); dcr->VolCatInfo.Slot = slot; /* slot to be loaded */ - changer = edit_device_codes(dcr, changer, - dcr->device->changer_command, "load"); - status = run_program(changer, timeout, NULL); + changer = edit_device_codes(dcr, changer, dcr->device->changer_command, "load"); + dev->close(); + Dmsg1(200, "Run program=%s\n", changer); + status = run_program_full_output(changer, timeout, results.addr()); if (status == 0) { Jmsg(jcr, M_INFO, 0, _("3305 Autochanger \"load slot %d, drive %d\", status is OK.\n"), slot, drive); - dev->Slot = slot; /* set currently loaded slot */ + Dmsg2(100, "load slot %d, drive %d, status is OK.\n", slot, drive); + dev->set_slot(slot); /* set currently loaded slot */ } else { - berrno be; - be.set_errno(status); - Jmsg(jcr, M_FATAL, 0, _("3992 Bad autochanger \"load slot %d, drive %d\": ERR=%s.\n"), - slot, drive, be.strerror()); - goto bail_out; + berrno be; + be.set_errno(status); + Dmsg3(100, "load slot %d, drive %d, bad stats=%s.\n", slot, drive, + be.bstrerror()); + Jmsg(jcr, M_FATAL, 0, _("3992 Bad autochanger \"load slot %d, drive %d\": " + "ERR=%s.\nResults=%s\n"), + slot, drive, be.bstrerror(), results.c_str()); + rtn_stat = -1; /* hard error */ + dev->set_slot(-1); /* mark unknown */ } + Dmsg2(100, "load slot %d status=%d\n", slot, status); unlock_changer(dcr); - Dmsg2(400, "load slot %d status=%d\n", slot, status); } else { status = 0; /* we got what we want */ - dev->Slot = slot; /* set currently loaded slot */ + dev->set_slot(slot); /* set currently loaded slot */ } - Dmsg1(400, "After changer, status=%d\n", status); + Dmsg1(100, "After changer, status=%d\n", status); if (status == 0) { /* did we succeed? */ rtn_stat = 1; /* tape loaded by changer */ } - } else { - rtn_stat = 0; /* no changer found */ } free_pool_memory(changer); return rtn_stat; bail_out: free_pool_memory(changer); - unlock_changer(dcr); return -1; } @@ -149,48 +235,64 @@ bail_out: /* * Returns: -1 if error from changer command * slot otherwise + * Note, this is safe to do without releasing the drive + * since it does not attempt load/unload a slot. */ int get_autochanger_loaded_slot(DCR *dcr) { JCR *jcr = dcr->jcr; - POOLMEM *changer, *results; + DEVICE *dev = dcr->dev; int status, loaded; uint32_t timeout = dcr->device->max_changer_wait; int drive = dcr->dev->drive_index; + POOL_MEM results(PM_MESSAGE); + POOLMEM *changer; - results = get_pool_memory(PM_MESSAGE); - changer = get_pool_memory(PM_FNAME); + if (!dev->is_autochanger()) { + return -1; + } + if (!dcr->device->changer_command) { +// Jmsg(jcr, M_FATAL, 0, _("3992 Missing Changer command.\n")); + return -1; + } + if (dev->get_slot() > 0) { + return dev->get_slot(); + } - lock_changer(dcr); + /* Virtual disk autochanger */ + if (dcr->device->changer_command[0] == 0) { + return 1; + } /* Find out what is loaded, zero means device is unloaded */ - Jmsg(jcr, M_INFO, 0, _("3301 Issuing autochanger \"loaded drive %d\" command.\n"), + changer = get_pool_memory(PM_FNAME); + lock_changer(dcr); + Jmsg(jcr, M_INFO, 0, _("3301 Issuing autochanger \"loaded? drive %d\" command.\n"), drive); changer = edit_device_codes(dcr, changer, dcr->device->changer_command, "loaded"); - *results = 0; - status = run_program(changer, timeout, results); - Dmsg3(50, "run_prog: %s stat=%d result=%s\n", changer, status, results); + Dmsg1(100, "Run program=%s\n", changer); + status = run_program_full_output(changer, timeout, results.addr()); + Dmsg3(100, "run_prog: %s stat=%d result=%s", changer, status, results.c_str()); if (status == 0) { - loaded = atoi(results); + loaded = str_to_int32(results.c_str()); if (loaded > 0) { - Jmsg(jcr, M_INFO, 0, _("3302 Autochanger \"loaded drive %d\", result is Slot %d.\n"), + Jmsg(jcr, M_INFO, 0, _("3302 Autochanger \"loaded? drive %d\", result is Slot %d.\n"), drive, loaded); - dcr->dev->Slot = loaded; + dev->set_slot(loaded); } else { - Jmsg(jcr, M_INFO, 0, _("3302 Autochanger \"loaded drive %d\", result: nothing loaded.\n"), + Jmsg(jcr, M_INFO, 0, _("3302 Autochanger \"loaded? drive %d\", result: nothing loaded.\n"), drive); - dcr->dev->Slot = 0; + dev->clear_slot(); /* unknown */ } } else { berrno be; be.set_errno(status); - Jmsg(jcr, M_INFO, 0, _("3991 Bad autochanger \"loaded drive %d\" command: ERR=%s.\n"), - drive, be.strerror()); + Jmsg(jcr, M_INFO, 0, _("3991 Bad autochanger \"loaded? drive %d\" command: " + "ERR=%s.\nResults=%s\n"), drive, be.bstrerror(), results.c_str()); loaded = -1; /* force unload */ } unlock_changer(dcr); free_pool_memory(changer); - free_pool_memory(results); return loaded; } @@ -198,7 +300,7 @@ static void lock_changer(DCR *dcr) { AUTOCHANGER *changer_res = dcr->device->changer_res; if (changer_res) { - Dmsg1(100, "Locking changer %s\n", changer_res->hdr.name); + Dmsg1(200, "Locking changer %s\n", changer_res->hdr.name); P(changer_res->changer_mutex); /* Lock changer script */ } } @@ -207,11 +309,209 @@ static void unlock_changer(DCR *dcr) { AUTOCHANGER *changer_res = dcr->device->changer_res; if (changer_res) { - Dmsg1(100, "Unlocking changer %s\n", changer_res->hdr.name); + Dmsg1(200, "Unlocking changer %s\n", changer_res->hdr.name); V(changer_res->changer_mutex); /* Unlock changer script */ } } +/* + * Unload the volume, if any, in this drive + * On entry: loaded == 0 -- nothing to do + * loaded < 0 -- check if anything to do + * loaded > 0 -- load slot == loaded + */ +bool unload_autochanger(DCR *dcr, int loaded) +{ + DEVICE *dev = dcr->dev; + JCR *jcr = dcr->jcr; + int slot; + uint32_t timeout = dcr->device->max_changer_wait; + bool ok = true; + + if (loaded == 0) { + return true; + } + + if (!dev->is_autochanger() || !dcr->device->changer_name || + !dcr->device->changer_command) { + return false; + } + + /* Virtual disk autochanger */ + if (dcr->device->changer_command[0] == 0) { + dev->clear_unload(); + return true; + } + + if (loaded < 0) { + loaded = get_autochanger_loaded_slot(dcr); + } + + if (loaded > 0) { + POOL_MEM results(PM_MESSAGE); + POOLMEM *changer = get_pool_memory(PM_FNAME); + lock_changer(dcr); + Jmsg(jcr, M_INFO, 0, + _("3307 Issuing autochanger \"unload slot %d, drive %d\" command.\n"), + loaded, dev->drive_index); + slot = dcr->VolCatInfo.Slot; + dcr->VolCatInfo.Slot = loaded; + changer = edit_device_codes(dcr, changer, + dcr->device->changer_command, "unload"); + dev->close(); + Dmsg1(100, "Run program=%s\n", changer); + int stat = run_program_full_output(changer, timeout, results.addr()); + dcr->VolCatInfo.Slot = slot; + if (stat != 0) { + berrno be; + be.set_errno(stat); + Jmsg(jcr, M_INFO, 0, _("3995 Bad autochanger \"unload slot %d, drive %d\": " + "ERR=%s\nResults=%s\n"), + loaded, dev->drive_index, be.bstrerror(), results.c_str()); + ok = false; + dev->clear_slot(); /* unknown */ + } else { + dev->set_slot(0); /* nothing loaded */ + } + unlock_changer(dcr); + + free_volume(dev); /* Free any volume associated with this drive */ + free_pool_memory(changer); + } + if (ok) { + dev->clear_unload(); + } + return ok; +} + +/* + * Unload the slot if mounted in a different drive + */ +static bool unload_other_drive(DCR *dcr, int slot) +{ + DEVICE *dev = NULL; + bool found = false; + AUTOCHANGER *changer = dcr->dev->device->changer_res; + DEVRES *device; + int retries = 0; /* wait for device retries */ + + if (!changer) { + return false; + } + if (changer->device->size() == 1) { + return true; + } + + foreach_alist(device, changer->device) { + if (device->dev && device->dev->get_slot() == slot) { + found = true; + dev = device->dev; + break; + } + } + if (!found) { + return true; + } + + /* The Volume we want is on another device. */ + if (dev->is_busy()) { + Dmsg4(100, "Vol %s for dev=%s in use dev=%s slot=%d\n", + dcr->VolumeName, dcr->dev->print_name(), + dev->print_name(), slot); + } + for (int i=0; i < 3; i++) { + if (dev->is_busy()) { + wait_for_device(dcr->jcr, retries); + continue; + } + break; + } + if (dev->is_busy()) { + Jmsg(dcr->jcr, M_WARNING, 0, _("Volume \"%s\" wanted on %s is in use by device %s\n"), + dcr->VolumeName, dcr->dev->print_name(), dev->print_name()); + Dmsg4(100, "Vol %s for dev=%s is busy dev=%s slot=%d\n", + dcr->VolumeName, dcr->dev->print_name(), dev->print_name(), dev->get_slot()); + Dmsg2(100, "num_writ=%d reserv=%d\n", dev->num_writers, dev->num_reserved()); + volume_unused(dcr); + return false; + } + return unload_dev(dcr, dev); +} + +/* + * Unconditionally unload a specified drive + */ +bool unload_dev(DCR *dcr, DEVICE *dev) +{ + JCR *jcr = dcr->jcr; + bool ok = true; + uint32_t timeout = dcr->device->max_changer_wait; + AUTOCHANGER *changer = dcr->dev->device->changer_res; + DEVICE *save_dev; + int save_slot; + + if (!changer) { + return false; + } + + save_dev = dcr->dev; /* save dcr device */ + dcr->dev = dev; /* temporarily point dcr at other device */ + + if (dev->get_slot() <= 0 && get_autochanger_loaded_slot(dcr) <= 0) { + dcr->dev = save_dev; + return false; + } + save_slot = dcr->VolCatInfo.Slot; + dcr->VolCatInfo.Slot = dev->get_slot(); + + dev->dlock(); + + POOLMEM *changer_cmd = get_pool_memory(PM_FNAME); + POOL_MEM results(PM_MESSAGE); + lock_changer(dcr); + Jmsg(jcr, M_INFO, 0, + _("3307 Issuing autochanger \"unload slot %d, drive %d\" command.\n"), + dev->get_slot(), dev->drive_index); + + Dmsg2(100, "Issuing autochanger \"unload slot %d, drive %d\" command.\n", + dev->get_slot(), dev->drive_index); + + changer_cmd = edit_device_codes(dcr, changer_cmd, + dcr->device->changer_command, "unload"); + dev->close(); + Dmsg2(200, "close dev=%s reserve=%d\n", dev->print_name(), + dev->num_reserved()); + Dmsg1(100, "Run program=%s\n", changer_cmd); + int stat = run_program_full_output(changer_cmd, timeout, results.addr()); + dcr->VolCatInfo.Slot = save_slot; + dcr->dev = save_dev; + if (stat != 0) { + berrno be; + be.set_errno(stat); + Jmsg(jcr, M_INFO, 0, _("3995 Bad autochanger \"unload slot %d, drive %d\": ERR=%s.\n"), + dev->get_slot(), dev->drive_index, be.bstrerror()); + + Dmsg3(100, "Bad autochanger \"unload slot %d, drive %d\": ERR=%s.\n", + dev->get_slot(), dev->drive_index, be.bstrerror()); + ok = false; + dev->clear_slot(); /* unknown */ + } else { + Dmsg2(100, "Slot %d unloaded %s\n", dev->get_slot(), dev->print_name()); + dev->set_slot(0); /* nothing loaded */ + } + if (ok) { + dev->clear_unload(); + } + unlock_changer(dcr); + + dev->dunlock(); + + free_volume(dev); /* Free any volume associated with this drive */ + free_pool_memory(changer_cmd); + return ok; +} + + /* * List the Volumes that are in the autoloader possibly @@ -221,94 +521,76 @@ static void unlock_changer(DCR *dcr) bool autochanger_cmd(DCR *dcr, BSOCK *dir, const char *cmd) { DEVICE *dev = dcr->dev; - JCR *jcr = dcr->jcr; uint32_t timeout = dcr->device->max_changer_wait; POOLMEM *changer; BPIPE *bpipe; - int slot, loaded; int len = sizeof_pool_memory(dir->msg) - 1; bool ok = false; int stat; if (!dev->is_autochanger() || !dcr->device->changer_name || !dcr->device->changer_command) { - bnet_fsend(dir, _("3993 Device %s not an autochanger device.\n"), + if (strcmp(cmd, "drives") == 0) { + dir->fsend("drives=1\n"); + } + dir->fsend(_("3993 Device %s not an autochanger device.\n"), dev->print_name()); return false; } - changer = get_pool_memory(PM_FNAME); - /* List command? */ - if (strcmp(cmd, "list") == 0) { - int drive = dev->device->drive_index; - /* Yes, to get a good listing, we unload any volumes */ - offline_or_rewind_dev(dev); - /* We are going to load a new tape, so close the device */ - force_close_device(dev); - - /* First unload any tape */ - loaded = get_autochanger_loaded_slot(dcr); - if (loaded > 0) { - bnet_fsend(dir, - _("3307 Issuing autochanger \"unload slot %d, drive %d\" command.\n"), - loaded, drive); - slot = dcr->VolCatInfo.Slot; - dcr->VolCatInfo.Slot = loaded; - changer = edit_device_codes(dcr, changer, - dcr->device->changer_command, "unload"); - lock_changer(dcr); - int stat = run_program(changer, timeout, NULL); - unlock_changer(dcr); - if (stat != 0) { - berrno be; - be.set_errno(stat); - Jmsg(jcr, M_INFO, 0, _("3995 Bad autochanger \"unload slot %d, drive %d\": ERR=%s.\n"), - slot, drive, be.strerror()); - } else { - dev->Slot = 0; /* nothing loaded */ - } - dcr->VolCatInfo.Slot = slot; + if (strcmp(cmd, "drives") == 0) { + AUTOCHANGER *changer_res = dcr->device->changer_res; + int drives = 1; + if (changer_res) { + drives = changer_res->device->size(); } + dir->fsend("drives=%d\n", drives); + Dmsg1(100, "drives=%d\n", drives); + return true; } + changer = get_pool_memory(PM_FNAME); + lock_changer(dcr); /* Now issue the command */ changer = edit_device_codes(dcr, changer, dcr->device->changer_command, cmd); - bnet_fsend(dir, _("3306 Issuing autochanger \"%s\" command.\n"), cmd); - lock_changer(dcr); + dir->fsend(_("3306 Issuing autochanger \"%s\" command.\n"), cmd); bpipe = open_bpipe(changer, timeout, "r"); if (!bpipe) { - unlock_changer(dcr); - bnet_fsend(dir, _("3996 Open bpipe failed.\n")); + dir->fsend(_("3996 Open bpipe failed.\n")); goto bail_out; } - if (strcmp(cmd, "list") == 0) { + if (bstrcmp(cmd, "list") || bstrcmp(cmd, "listall")) { /* Get output from changer */ while (fgets(dir->msg, len, bpipe->rfd)) { dir->msglen = strlen(dir->msg); Dmsg1(100, "msg); bnet_send(dir); } - } else { + } else if (strcmp(cmd, "slots") == 0 ) { + char buf[100], *p; /* For slots command, read a single line */ - bstrncpy(dir->msg, "slots=", len); - fgets(dir->msg+6, len-6, bpipe->rfd); - dir->msglen = strlen(dir->msg); + buf[0] = 0; + fgets(buf, sizeof(buf)-1, bpipe->rfd); + buf[sizeof(buf)-1] = 0; + /* Strip any leading space in front of # of slots */ + for (p=buf; B_ISSPACE(*p); p++) + { } + dir->fsend("slots=%s", p); Dmsg1(100, "msg); - bnet_send(dir); - } + } stat = close_bpipe(bpipe); - unlock_changer(dcr); if (stat != 0) { berrno be; be.set_errno(stat); - bnet_fsend(dir, "Autochanger error: ERR=%s\n", be.strerror()); + dir->fsend(_("Autochanger error: ERR=%s\n"), be.bstrerror()); } bnet_sig(dir, BNET_EOD); ok = true; bail_out: + unlock_changer(dcr); free_pool_memory(changer); return true; }