]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/dircmd.c
Eliminate dependency on man2html.
[bacula/bacula] / bacula / src / stored / dircmd.c
1 /*
2  *  This file handles accepting Director Commands
3  *
4  *    Most Director commands are handled here, with the
5  *    exception of the Job command command and subsequent
6  *    subcommands that are handled
7  *    in job.c.
8  *
9  *    N.B. in this file, in general we must use P(dev->mutex) rather
10  *      than lock_device(dev) so that we can examine the blocked
11  *      state rather than blocking ourselves because a Job
12  *      thread has the device blocked. In some "safe" cases,
13  *      we can do things to a blocked device. CAREFUL!!!!
14  *
15  *    File daemon commands are handled in fdcmd.c
16  *
17  *     Kern Sibbald, May MMI
18  *
19  *   Version $Id$
20  *
21  */
22 /*
23    Copyright (C) 2001-2006 Kern Sibbald
24
25    This program is free software; you can redistribute it and/or
26    modify it under the terms of the GNU General Public License
27    version 2 as amended with additional clauses defined in the
28    file LICENSE in the main source directory.
29
30    This program is distributed in the hope that it will be useful,
31    but WITHOUT ANY WARRANTY; without even the implied warranty of
32    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
33    the file LICENSE for additional details.
34
35  */
36
37 #include "bacula.h"
38 #include "stored.h"
39
40 /* Exported variables */
41
42 /* Imported variables */
43 extern BSOCK *filed_chan;
44 extern int r_first, r_last;
45 extern struct s_res resources[];
46 extern struct s_last_job last_job;
47 extern bool init_done;
48
49 /* Static variables */
50 static char derrmsg[]     = "3900 Invalid command\n";
51 static char OKsetdebug[]  = "3000 OK setdebug=%d\n";
52 static char illegal_cmd[] = "3997 Illegal command for a Director with Monitor directive enabled\n";
53
54 /* Imported functions */
55 extern void terminate_child();
56 extern bool job_cmd(JCR *jcr);
57 extern bool use_cmd(JCR *jcr);
58 extern bool run_cmd(JCR *jcr);
59 extern bool status_cmd(JCR *sjcr);
60 extern bool qstatus_cmd(JCR *jcr);
61 //extern bool query_cmd(JCR *jcr);
62
63 /* Forward referenced functions */
64 static bool label_cmd(JCR *jcr);
65 static bool relabel_cmd(JCR *jcr);
66 static bool readlabel_cmd(JCR *jcr);
67 static bool release_cmd(JCR *jcr);
68 static bool setdebug_cmd(JCR *jcr);
69 static bool cancel_cmd(JCR *cjcr);
70 static bool mount_cmd(JCR *jcr);
71 static bool unmount_cmd(JCR *jcr);
72 static bool bootstrap_cmd(JCR *jcr);
73 static bool changer_cmd(JCR *sjcr);
74 static bool do_label(JCR *jcr, int relabel);
75 static DCR *find_device(JCR *jcr, POOL_MEM &dev_name, int drive);
76 static void read_volume_label(JCR *jcr, DEVICE *dev, int Slot);
77 static void label_volume_if_ok(DCR *dcr, char *oldname,
78                                char *newname, char *poolname,
79                                int Slot, int relabel);
80 static bool try_autoload_device(JCR *jcr, int slot, const char *VolName);
81 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev);
82
83 struct s_cmds {
84    const char *cmd;
85    bool (*func)(JCR *jcr);
86    int monitoraccess; /* specify if monitors have access to this function */
87 };
88
89 /*
90  * The following are the recognized commands from the Director.
91  */
92 static struct s_cmds cmds[] = {
93    {"JobId=",      job_cmd,         0},     /* start Job */
94    {"autochanger", changer_cmd,     0},
95    {"bootstrap",   bootstrap_cmd,   0},
96    {"cancel",      cancel_cmd,      0},
97    {"label",       label_cmd,       0},     /* label a tape */
98    {"mount",       mount_cmd,       0},
99    {"readlabel",   readlabel_cmd,   0},
100    {"release",     release_cmd,     0},
101    {"relabel",     relabel_cmd,     0},     /* relabel a tape */
102    {"setdebug=",   setdebug_cmd,    0},     /* set debug level */
103    {"status",      status_cmd,      1},
104    {".status",     qstatus_cmd,     1},
105    {"unmount",     unmount_cmd,     0},
106    {"use storage=", use_cmd,        0},
107    {"run",         run_cmd,         0},
108 // {"query",       query_cmd,       0},
109    {NULL,        NULL}                      /* list terminator */
110 };
111
112
113 /*
114  * Connection request. We accept connections either from the
115  *  Director or a Client (File daemon).
116  *
117  * Note, we are running as a seperate thread of the Storage daemon.
118  *  and it is because a Director has made a connection with
119  *  us on the "Message" channel.
120  *
121  * Basic tasks done here:
122  *  - Create a JCR record
123  *  - If it was from the FD, call handle_filed_connection()
124  *  - Authenticate the Director
125  *  - We wait for a command
126  *  - We execute the command
127  *  - We continue or exit depending on the return status
128  */
129 void *handle_connection_request(void *arg)
130 {
131    BSOCK *bs = (BSOCK *)arg;
132    JCR *jcr;
133    int i;
134    bool found, quit;
135    int bnet_stat = 0;
136    char name[MAX_NAME_LENGTH];
137
138    if (bnet_recv(bs) <= 0) {
139       Emsg0(M_ERROR, 0, _("Connection request failed.\n"));
140       bnet_close(bs);
141       return NULL;
142    }
143
144    /*
145     * Do a sanity check on the message received
146     */
147    if (bs->msglen < 25 || bs->msglen > (int)sizeof(name)-25) {
148       Emsg1(M_ERROR, 0, _("Invalid connection. Len=%d\n"), bs->msglen);
149       bnet_close(bs);
150       return NULL;
151    }
152    /*
153     * See if this is a File daemon connection. If so
154     *   call FD handler.
155     */
156    Dmsg1(110, "Conn: %s", bs->msg);
157    if (sscanf(bs->msg, "Hello Start Job %127s", name) == 1) {
158       handle_filed_connection(bs, name);
159       return NULL;
160    }
161
162    /* 
163     * This is a connection from the Director, so setup a JCR 
164     */
165    Dmsg0(110, "Start Dir Job\n");
166    jcr = new_jcr(sizeof(JCR), stored_free_jcr); /* create Job Control Record */
167    jcr->dir_bsock = bs;               /* save Director bsock */
168    jcr->dir_bsock->jcr = jcr;
169    jcr->dcrs = New(alist(10, not_owned_by_alist));
170    /* Initialize FD start condition variable */
171    int errstat = pthread_cond_init(&jcr->job_start_wait, NULL);
172    if (errstat != 0) {
173       Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), strerror(errstat));
174       goto bail_out;
175    }
176
177    Dmsg0(1000, "stored in start_job\n");
178
179    /*
180     * Authenticate the Director
181     */
182    if (!authenticate_director(jcr)) {
183       Jmsg(jcr, M_FATAL, 0, _("Unable to authenticate Director\n"));
184       goto bail_out;
185    }
186    Dmsg0(90, "Message channel init completed.\n");
187
188    for (quit=false; !quit;) {
189       /* Read command */
190       if ((bnet_stat = bnet_recv(bs)) <= 0) {
191          break;               /* connection terminated */
192       }
193       Dmsg1(199, "<dird: %s\n", bs->msg);
194       /* Ensure that device initialization is complete */
195       while (!init_done) {
196          bmicrosleep(1, 0);
197       }
198       found = false;
199       for (i=0; cmds[i].cmd; i++) {
200         if (strncmp(cmds[i].cmd, bs->msg, strlen(cmds[i].cmd)) == 0) {
201            if ((!cmds[i].monitoraccess) && (jcr->director->monitor)) {
202               Dmsg1(100, "Command %s illegal.\n", cmds[i].cmd);
203               bnet_fsend(bs, illegal_cmd);
204               bnet_sig(bs, BNET_EOD);
205               break;
206            }
207            Dmsg1(200, "Do command: %s\n", cmds[i].cmd);
208            if (!cmds[i].func(jcr)) { /* do command */
209               quit = true; /* error, get out */
210               Dmsg1(190, "Command %s reqeusts quit\n", cmds[i].cmd);
211            }
212            found = true;             /* indicate command found */
213            break;
214         }
215       }
216       if (!found) {                   /* command not found */
217         bnet_fsend(bs, derrmsg);
218         break;
219       }
220    }
221 bail_out:
222    generate_daemon_event(jcr, "JobEnd");
223    dequeue_messages(jcr);             /* send any queued messages */
224    bnet_sig(bs, BNET_TERMINATE);
225    free_jcr(jcr);
226    return NULL;
227 }
228
229 /*
230  * Set debug level as requested by the Director
231  *
232  */
233 static bool setdebug_cmd(JCR *jcr)
234 {
235    BSOCK *dir = jcr->dir_bsock;
236    int level, trace_flag;
237
238    Dmsg1(10, "setdebug_cmd: %s", dir->msg);
239    if (sscanf(dir->msg, "setdebug=%d trace=%d", &level, &trace_flag) != 2 || level < 0) {
240       bnet_fsend(dir, _("3991 Bad setdebug command: %s\n"), dir->msg);
241       return 0;
242    }
243    debug_level = level;
244    set_trace(trace_flag);
245    return bnet_fsend(dir, OKsetdebug, level);
246 }
247
248
249 /*
250  * Cancel a Job
251  */
252 static bool cancel_cmd(JCR *cjcr)
253 {
254    BSOCK *dir = cjcr->dir_bsock;
255    int oldStatus;
256    char Job[MAX_NAME_LENGTH];
257    JCR *jcr;
258
259    if (sscanf(dir->msg, "cancel Job=%127s", Job) == 1) {
260       if (!(jcr=get_jcr_by_full_name(Job))) {
261          bnet_fsend(dir, _("3904 Job %s not found.\n"), Job);
262       } else {
263          jcr->lock();
264          oldStatus = jcr->JobStatus;
265          set_jcr_job_status(jcr, JS_Canceled);
266          if (!jcr->authenticated && oldStatus == JS_WaitFD) {
267             pthread_cond_signal(&jcr->job_start_wait); /* wake waiting thread */
268          }
269          jcr->unlock();
270          if (jcr->file_bsock) {
271             bnet_sig(jcr->file_bsock, BNET_TERMINATE);
272          }
273          /* If thread waiting on mount, wake him */
274          if (jcr->dcr && jcr->dcr->dev && jcr->dcr->dev->waiting_for_mount()) {
275             pthread_cond_broadcast(&jcr->dcr->dev->wait_next_vol);
276             pthread_cond_broadcast(&wait_device_release);
277          }
278          if (jcr->read_dcr && jcr->read_dcr->dev && jcr->read_dcr->dev->waiting_for_mount()) {
279             pthread_cond_broadcast(&jcr->read_dcr->dev->wait_next_vol);
280             pthread_cond_broadcast(&wait_device_release);
281          }
282          Jmsg(jcr, M_INFO, 0, _("Job marked to be canceled.\n"));
283          bnet_fsend(dir, _("3000 Job %s marked to be canceled.\n"), jcr->Job);
284          free_jcr(jcr);
285       }
286    } else {
287       bnet_fsend(dir, _("3903 Error scanning cancel command.\n"));
288    }
289    bnet_sig(dir, BNET_EOD);
290    return 1;
291 }
292
293 /*
294  * Label a Volume
295  *
296  */
297 static bool label_cmd(JCR *jcr)
298 {
299    return do_label(jcr, 0);
300 }
301
302 static bool relabel_cmd(JCR *jcr)
303 {
304    return do_label(jcr, 1);
305 }
306
307 static bool do_label(JCR *jcr, int relabel)
308 {
309    POOLMEM *newname, *oldname, *poolname, *mtype;
310    POOL_MEM dev_name;
311    BSOCK *dir = jcr->dir_bsock;
312    DCR *dcr;
313    DEVICE *dev;
314    bool ok = false;
315    int slot;
316    int drive;
317
318    newname = get_memory(dir->msglen+1);
319    oldname = get_memory(dir->msglen+1);
320    poolname = get_memory(dir->msglen+1);
321    mtype = get_memory(dir->msglen+1);
322    if (relabel) {
323       if (sscanf(dir->msg, "relabel %127s OldName=%127s NewName=%127s PoolName=%127s "
324                  "MediaType=%127s Slot=%d drive=%d",
325                   dev_name.c_str(), oldname, newname, poolname, mtype, 
326                   &slot, &drive) == 7) {
327          ok = true;
328       }
329    } else {
330       *oldname = 0;
331       if (sscanf(dir->msg, "label %127s VolumeName=%127s PoolName=%127s "
332                  "MediaType=%127s Slot=%d drive=%d", 
333           dev_name.c_str(), newname, poolname, mtype, &slot, &drive) == 6) {
334          ok = true;
335       }
336    }
337    if (ok) {
338       unbash_spaces(newname);
339       unbash_spaces(oldname);
340       unbash_spaces(poolname);
341       unbash_spaces(mtype);
342       dcr = find_device(jcr, dev_name, drive);
343       if (dcr) {
344          dev = dcr->dev;
345          P(dev->mutex);               /* Use P to avoid indefinite block */
346          if (!dev->is_open()) {
347             Dmsg1(400, "Can %slabel. Device is not open\n", relabel?"re":"");
348             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
349             dev->close();
350          /* Under certain "safe" conditions, we can steal the lock */
351          } else if (dev->can_steal_lock()) {
352             Dmsg0(400, "Can relabel. can_steal_lock\n");
353             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
354          } else if (dev->is_busy() || dev->is_blocked()) {
355             send_dir_busy_message(dir, dev);
356          } else {                     /* device not being used */
357             Dmsg0(400, "Can relabel. device not used\n");
358             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
359          }
360          V(dev->mutex);
361          free_dcr(dcr);
362          jcr->dcr = NULL;
363       } else {
364          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), dev_name.c_str());
365       }
366    } else {
367       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
368       pm_strcpy(jcr->errmsg, dir->msg);
369       bnet_fsend(dir, _("3903 Error scanning label command: %s\n"), jcr->errmsg);
370    }
371    free_memory(oldname);
372    free_memory(newname);
373    free_memory(poolname);
374    free_memory(mtype);
375    bnet_sig(dir, BNET_EOD);
376    return true;
377 }
378
379 /*
380  * Read the tape label and determine if we can safely
381  * label the tape (not a Bacula volume), then label it.
382  *
383  *  Enter with the mutex set
384  */
385 static void label_volume_if_ok(DCR *dcr, char *oldname,
386                                char *newname, char *poolname,
387                                int slot, int relabel)
388 {
389    BSOCK *dir = dcr->jcr->dir_bsock;
390    bsteal_lock_t hold;
391    DEVICE *dev = dcr->dev;
392    int label_status;
393    int mode;
394    const char *volname = (relabel == 1) ? oldname : newname;
395    char ed1[50];
396
397    steal_device_lock(dev, &hold, BST_WRITING_LABEL);
398    Dmsg1(100, "Stole device %s lock, writing label.\n", dev->print_name());
399
400
401    Dmsg0(90, "try_autoload_device - looking for volume_info\n");
402    if (!try_autoload_device(dcr->jcr, slot, volname)) {
403       goto bail_out;                  /* error */
404    }
405
406    /* Ensure that the device is open -- autoload_device() closes it */
407    if (dev->is_tape()) {
408       mode = OPEN_READ_WRITE;
409    } else {
410       mode = CREATE_READ_WRITE;
411    }
412
413    if (relabel) {
414       dev->truncating = true;         /* let open() know we will truncate it */
415    }
416    /* Set old volume name for open if relabeling */
417    bstrncpy(dcr->VolCatInfo.VolCatName, volname, sizeof(dcr->VolCatInfo.VolCatName));
418    if (dev->open(dcr, mode) < 0) {
419       bnet_fsend(dir, _("3910 Unable to open device %s: ERR=%s\n"),
420          dev->print_name(), dev->strerror());
421       goto bail_out;      
422    }
423
424    /* See what we have for a Volume */
425    label_status = read_dev_volume_label(dcr);
426    
427    /* Set new volume name */
428    bstrncpy(dcr->VolCatInfo.VolCatName, newname, sizeof(dcr->VolCatInfo.VolCatName));
429    switch(label_status) {
430    case VOL_NAME_ERROR:
431    case VOL_VERSION_ERROR:
432    case VOL_LABEL_ERROR:
433    case VOL_OK:
434       if (!relabel) {
435          bnet_fsend(dir, _(
436             "3920 Cannot label Volume because it is already labeled: \"%s\"\n"),
437              dev->VolHdr.VolumeName);
438          break;
439       }
440
441       /* Relabel request. If oldname matches, continue */
442       if (strcmp(oldname, dev->VolHdr.VolumeName) != 0) {
443          bnet_fsend(dir, _("3921 Wrong volume mounted.\n"));
444          break;
445       }
446       if (dev->label_type != B_BACULA_LABEL) {
447          bnet_fsend(dir, _("3922 Cannot relabel an ANSI/IBM labeled Volume.\n"));
448          break;
449       }
450       /* Fall through wanted! */
451    case VOL_IO_ERROR:
452    case VOL_NO_LABEL:
453       if (!write_new_volume_label_to_dev(dcr, newname, poolname, 
454            relabel, true /* write dvd now */)) {
455          bnet_fsend(dir, _("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror());
456          break;
457       }
458       bstrncpy(dcr->VolumeName, newname, sizeof(dcr->VolumeName));
459       /* The following 3000 OK label. string is scanned in ua_label.c */
460       bnet_fsend(dir, "3000 OK label. VolBytes=%s DVD=%d Volume=\"%s\" Device=%s\n",
461                  edit_uint64(dev->VolCatInfo.VolCatBytes, ed1),
462                  dev->is_dvd()?1:0, newname, dev->print_name());
463       break;
464    case VOL_NO_MEDIA:
465       bnet_fsend(dir, _("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror());
466       break;
467    default:
468       bnet_fsend(dir, _("3913 Cannot label Volume. "
469 "Unknown status %d from read_volume_label()\n"), label_status);
470       break;
471    }
472
473 bail_out:
474    if (!dev->is_open()) {
475       free_volume(dev);
476    }
477    give_back_device_lock(dev, &hold);
478    return;
479 }
480
481
482 /*
483  * Read the tape label
484  *
485  *  Enter with the mutex set
486  */
487 static bool read_label(DCR *dcr)
488 {
489    int ok;
490    JCR *jcr = dcr->jcr;
491    BSOCK *dir = jcr->dir_bsock;
492    bsteal_lock_t hold;
493    DEVICE *dev = dcr->dev;
494
495    steal_device_lock(dev, &hold, BST_DOING_ACQUIRE);
496
497    dcr->VolumeName[0] = 0;
498    dev->clear_labeled();              /* force read of label */
499    switch (read_dev_volume_label(dcr)) {
500    case VOL_OK:
501       bnet_fsend(dir, _("3001 Mounted Volume: %s\n"), dev->VolHdr.VolumeName);
502       ok = true;
503       break;
504    default:
505       bnet_fsend(dir, _("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
506          dev->print_name(), jcr->errmsg);
507       ok = false;
508       break;
509    }
510    give_back_device_lock(dev, &hold);
511    return ok;
512 }
513
514 /* 
515  * Searches for device by name, and if found, creates a dcr and
516  *  returns it.
517  */
518 static DCR *find_device(JCR *jcr, POOL_MEM &devname, int drive)
519 {
520    DEVRES *device;
521    AUTOCHANGER *changer;
522    bool found = false;
523    DCR *dcr = NULL;
524
525    unbash_spaces(devname);
526    foreach_res(device, R_DEVICE) {
527       /* Find resource, and make sure we were able to open it */
528       if (fnmatch(device->hdr.name, devname.c_str(), 0) == 0) {
529          if (!device->dev) {
530             device->dev = init_dev(jcr, device);
531          }
532          if (!device->dev) {
533             Jmsg(jcr, M_WARNING, 0, _("\n"
534                "     Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
535                  devname.c_str());
536             continue;
537          }
538          Dmsg1(20, "Found device %s\n", device->hdr.name);
539          found = true;
540          break;
541       }
542    }
543    if (!found) {
544       foreach_res(changer, R_AUTOCHANGER) {
545          /* Find resource, and make sure we were able to open it */
546          if (fnmatch(devname.c_str(), changer->hdr.name, 0) == 0) {
547             /* Try each device in this AutoChanger */
548             foreach_alist(device, changer->device) {
549                Dmsg1(100, "Try changer device %s\n", device->hdr.name);
550                if (!device->dev) {
551                   device->dev = init_dev(jcr, device);
552                }
553                if (!device->dev) {
554                   Dmsg1(100, "Device %s could not be opened. Skipped\n", devname.c_str());
555                   Jmsg(jcr, M_WARNING, 0, _("\n"
556                      "     Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
557                        device->hdr.name, devname.c_str());
558                   continue;
559                }
560                if (!device->dev->autoselect) {
561                   Dmsg1(100, "Device %s not autoselect skipped.\n", devname.c_str());
562                   continue;              /* device is not available */
563                }
564                if (drive < 0 || drive == (int)device->dev->drive_index) {
565                   Dmsg1(20, "Found changer device %s\n", device->hdr.name);
566                   found = true;
567                   break;
568                }
569                Dmsg3(100, "Device %s drive wrong: want=%d got=%d skipping\n",
570                   devname.c_str(), drive, (int)device->dev->drive_index);
571             }
572             break;                    /* we found it but could not open a device */
573          }
574       }
575    }
576
577    if (found) {
578       Dmsg1(100, "Found device %s\n", device->hdr.name);
579       dcr = new_dcr(jcr, device->dev);
580       dcr->device = device;
581       jcr->dcr = dcr;
582    }
583    return dcr;
584 }
585
586
587 /*
588  * Mount command from Director
589  */
590 static bool mount_cmd(JCR *jcr)
591 {
592    POOL_MEM devname;
593    BSOCK *dir = jcr->dir_bsock;
594    DEVICE *dev;
595    DCR *dcr;
596    int drive;
597    int slot = 0;
598    bool ok;
599
600    ok = sscanf(dir->msg, "mount %127s drive=%d slot=%d", devname.c_str(), 
601                &drive, &slot) == 3;
602    if (!ok) {
603       ok = sscanf(dir->msg, "mount %127s drive=%d", devname.c_str(), &drive) == 2;
604    }
605    if (ok) {
606       dcr = find_device(jcr, devname, drive);
607       if (dcr) {
608          dev = dcr->dev;
609          P(dev->mutex);               /* Use P to avoid indefinite block */
610          Dmsg1(100, "mount cmd blocked=%d\n", dev->dev_blocked);
611          switch (dev->dev_blocked) {         /* device blocked? */
612          case BST_WAITING_FOR_SYSOP:
613             /* Someone is waiting, wake him */
614             Dmsg0(100, "Waiting for mount. Attempting to wake thread\n");
615             dev->dev_blocked = BST_MOUNT;
616             bnet_fsend(dir, "3001 OK mount. Device=%s\n", 
617                dev->print_name());
618             pthread_cond_broadcast(&dev->wait_next_vol);
619             pthread_cond_broadcast(&wait_device_release);
620             break;
621
622          /* In both of these two cases, we (the user) unmounted the Volume */
623          case BST_UNMOUNTED_WAITING_FOR_SYSOP:
624          case BST_UNMOUNTED:
625             if (dev->is_autochanger() && slot > 0) {
626                try_autoload_device(jcr, slot, "");
627             }
628             /* We freed the device, so reopen it and wake any waiting threads */
629             if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
630                bnet_fsend(dir, _("3901 open device failed: ERR=%s\n"),
631                   dev->bstrerror());
632                if (dev->dev_blocked == BST_UNMOUNTED) {
633                   /* We blocked the device, so unblock it */
634                   Dmsg0(100, "Unmounted. Unblocking device\n");
635                   unblock_device(dev);
636                }
637                break;
638             }
639             read_dev_volume_label(dcr);
640             if (dev->dev_blocked == BST_UNMOUNTED) {
641                /* We blocked the device, so unblock it */
642                Dmsg0(100, "Unmounted. Unblocking device\n");
643                read_label(dcr);       /* this should not be necessary */
644                unblock_device(dev);
645             } else {
646                Dmsg0(100, "Unmounted waiting for mount. Attempting to wake thread\n");
647                dev->dev_blocked = BST_MOUNT;
648             }
649             if (dev->is_labeled()) {
650                bnet_fsend(dir, _("3001 Device %s is mounted with Volume \"%s\"\n"),
651                   dev->print_name(), dev->VolHdr.VolumeName);
652             } else {
653                bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"
654                                  "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
655                           dev->print_name());
656             }
657             pthread_cond_broadcast(&dev->wait_next_vol);
658             pthread_cond_broadcast(&wait_device_release);
659             break;
660
661          case BST_DOING_ACQUIRE:
662             bnet_fsend(dir, _("3001 Device %s is doing acquire.\n"),
663                        dev->print_name());
664             break;
665
666          case BST_WRITING_LABEL:
667             bnet_fsend(dir, _("3903 Device %s is being labeled.\n"), 
668                dev->print_name());
669             break;
670
671          case BST_NOT_BLOCKED:
672             if (dev->is_autochanger() && slot > 0) {
673                try_autoload_device(jcr, slot, "");
674             }
675             if (dev->is_open()) {
676                if (dev->is_labeled()) {
677                   bnet_fsend(dir, _("3001 Device %s is mounted with Volume \"%s\"\n"),
678                      dev->print_name(), dev->VolHdr.VolumeName);
679                } else {
680                   bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"
681                                  "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
682                              dev->print_name());
683                }
684             } else if (dev->is_tape()) {
685                if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
686                   bnet_fsend(dir, _("3901 open device failed: ERR=%s\n"),
687                      dev->bstrerror());
688                   break;
689                }
690                read_label(dcr);
691                if (dev->is_labeled()) {
692                   bnet_fsend(dir, _("3001 Device %s is already mounted with Volume \"%s\"\n"),
693                      dev->print_name(), dev->VolHdr.VolumeName);
694                } else {
695                   bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"
696                                     "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
697                              dev->print_name());
698                }
699             } else if (dev->is_dvd()) {
700                if (mount_dvd(dev, 1)) {
701                   bnet_fsend(dir, _("3002 Device %s is mounted.\n"), 
702                      dev->print_name());
703                } else {
704                   bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
705                } 
706             } else { /* must be file */
707                bnet_fsend(dir, _("3906 File device %s is always mounted.\n"),
708                   dev->print_name());
709             }
710             break;
711
712          default:
713             bnet_fsend(dir, _("3905 Bizarre wait state %d\n"), dev->dev_blocked);
714             break;
715          }
716          V(dev->mutex);
717          free_dcr(dcr);
718          jcr->dcr = NULL;
719       } else {
720          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
721       }
722    } else {
723       pm_strcpy(jcr->errmsg, dir->msg);
724       bnet_fsend(dir, _("3909 Error scanning mount command: %s\n"), jcr->errmsg);
725    }
726    bnet_sig(dir, BNET_EOD);
727    return true;
728 }
729
730 /*
731  * unmount command from Director
732  */
733 static bool unmount_cmd(JCR *jcr)
734 {
735    POOL_MEM devname;
736    BSOCK *dir = jcr->dir_bsock;
737    DEVICE *dev;
738    DCR *dcr;
739    int drive;
740
741    if (sscanf(dir->msg, "unmount %127s drive=%d", devname.c_str(), &drive) == 2) {
742       dcr = find_device(jcr, devname, drive);
743       if (dcr) {
744          dev = dcr->dev;
745          P(dev->mutex);               /* Use P to avoid indefinite block */
746          if (!dev->is_open()) {
747             if (!dev->is_busy()) {
748                unload_autochanger(jcr->dcr, -1);          
749             }
750             if (dev->is_dvd()) {
751                if (unmount_dvd(dev, 0)) {
752                   bnet_fsend(dir, _("3002 Device %s unmounted.\n"), 
753                      dev->print_name());
754                } else {
755                   bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
756                } 
757             } else {
758                Dmsg0(90, "Device already unmounted\n");
759                bnet_fsend(dir, _("3901 Device %s is already unmounted.\n"), 
760                   dev->print_name());
761             }
762          } else if (dev->dev_blocked == BST_WAITING_FOR_SYSOP) {
763             Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
764                dev->dev_blocked);
765             if (!unload_autochanger(jcr->dcr, -1)) {
766                dev->close();
767             }
768             if (dev->is_dvd() && !unmount_dvd(dev, 0)) {
769                bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
770             } else {
771                dev->dev_blocked = BST_UNMOUNTED_WAITING_FOR_SYSOP;
772                bnet_fsend(dir, _("3001 Device %s unmounted.\n"), 
773                   dev->print_name());
774             }
775
776          } else if (dev->dev_blocked == BST_DOING_ACQUIRE) {
777             bnet_fsend(dir, _("3902 Device %s is busy in acquire.\n"), 
778                dev->print_name());
779
780          } else if (dev->dev_blocked == BST_WRITING_LABEL) {
781             bnet_fsend(dir, _("3903 Device %s is being labeled.\n"), 
782                dev->print_name());
783
784          } else if (dev->is_busy()) {
785             send_dir_busy_message(dir, dev);
786          } else {                     /* device not being used */
787             Dmsg0(90, "Device not in use, unmounting\n");
788             /* On FreeBSD, I am having ASSERT() failures in block_device()
789              * and I can only imagine that the thread id that we are
790              * leaving in no_wait_id is being re-used. So here,
791              * we simply do it by hand.  Gross, but a solution.
792              */
793             /*  block_device(dev, BST_UNMOUNTED); replace with 2 lines below */
794             dev->dev_blocked = BST_UNMOUNTED;
795             dev->no_wait_id = 0;
796             if (!unload_autochanger(jcr->dcr, -1)) {
797                dev->close();
798             }
799             if (dev->is_dvd() && !unmount_dvd(dev, 0)) {
800                bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
801             } else {
802                bnet_fsend(dir, _("3002 Device %s unmounted.\n"), 
803                   dev->print_name());
804             }
805          }
806          V(dev->mutex);
807          free_dcr(dcr);
808          jcr->dcr = NULL;
809       } else {
810          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
811       }
812    } else {
813       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
814       pm_strcpy(jcr->errmsg, dir->msg);
815       bnet_fsend(dir, _("3907 Error scanning unmount command: %s\n"), jcr->errmsg);
816    }
817    bnet_sig(dir, BNET_EOD);
818    return true;
819 }
820
821 /*
822  * Release command from Director. This rewinds the device and if
823  *   configured does a offline and ensures that Bacula will
824  *   re-read the label of the tape before continuing. This gives
825  *   the operator the chance to change the tape anytime before the
826  *   next job starts.
827  */
828 static bool release_cmd(JCR *jcr)
829 {
830    POOL_MEM devname;
831    BSOCK *dir = jcr->dir_bsock;
832    DEVICE *dev;
833    DCR *dcr;
834    int drive;
835
836    if (sscanf(dir->msg, "release %127s drive=%d", devname.c_str(), &drive) == 2) {
837       dcr = find_device(jcr, devname, drive);
838       if (dcr) {
839          dev = dcr->dev;
840          P(dev->mutex);               /* Use P to avoid indefinite block */
841          if (!dev->is_open()) {
842             Dmsg0(90, "Device already released\n");
843             bnet_fsend(dir, _("3921 Device %s already released.\n"), 
844                dev->print_name());
845
846          } else if (dev->dev_blocked == BST_WAITING_FOR_SYSOP ||
847                     dev->dev_blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP) {
848             Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
849                dev->dev_blocked);
850             bnet_fsend(dir, _("3922 Device %s waiting for mount.\n"), 
851                dev->print_name());
852
853          } else if (dev->dev_blocked == BST_DOING_ACQUIRE) {
854             bnet_fsend(dir, _("3923 Device %s is busy in acquire.\n"), 
855                dev->print_name());
856
857          } else if (dev->dev_blocked == BST_WRITING_LABEL) {
858             bnet_fsend(dir, _("3914 Device %s is being labeled.\n"), 
859                dev->print_name());
860
861          } else if (dev->is_busy()) {
862             send_dir_busy_message(dir, dev);
863          } else {                     /* device not being used */
864             Dmsg0(90, "Device not in use, unmounting\n");
865             release_volume(jcr->dcr);
866             bnet_fsend(dir, _("3022 Device %s released.\n"), 
867                dev->print_name());
868          }
869          V(dev->mutex);
870          free_dcr(dcr);
871          jcr->dcr = NULL;
872       } else {
873          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
874       }
875    } else {
876       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
877       pm_strcpy(jcr->errmsg, dir->msg);
878       bnet_fsend(dir, _("3927 Error scanning release command: %s\n"), jcr->errmsg);
879    }
880    bnet_sig(dir, BNET_EOD);
881    return true;
882 }
883
884
885 static bool bootstrap_cmd(JCR *jcr)
886 {
887    return get_bootstrap_file(jcr, jcr->dir_bsock);
888 }
889
890 /*
891  * Autochanger command from Director
892  */
893 static bool changer_cmd(JCR *jcr)
894 {
895    POOL_MEM devname;
896    BSOCK *dir = jcr->dir_bsock;
897    DEVICE *dev;
898    DCR *dcr;
899    const char *cmd = NULL;
900    bool ok = false;
901    /*
902     * A safe_cmd may call autochanger script but does not load/unload
903     *    slots so it can be done at the same time that the drive is open.
904     */
905    bool safe_cmd = false;
906
907    if (sscanf(dir->msg, "autochanger list %127s", devname.c_str()) == 1) {
908       cmd = "list";
909       safe_cmd = ok = true;
910    } else if (sscanf(dir->msg, "autochanger slots %127s", devname.c_str()) == 1) {
911       cmd = "slots";
912       safe_cmd = ok = true;
913    } else if (sscanf(dir->msg, "autochanger drives %127s", devname.c_str()) == 1) {
914       cmd = "drives";
915       safe_cmd = ok = true;
916    }
917    if (ok) {
918       dcr = find_device(jcr, devname, -1);
919       if (dcr) {
920          dev = dcr->dev;
921          P(dev->mutex);               /* Use P to avoid indefinite block */
922          if (!dev->device->changer_res) {
923             bnet_fsend(dir, _("3995 Device %s is not an autochanger.\n"), 
924                dev->print_name());
925          /* Under certain "safe" conditions, we can steal the lock */
926          } else if (safe_cmd || !dev->is_open() || dev->can_steal_lock()) {
927             autochanger_cmd(dcr, dir, cmd);
928          } else if (dev->is_busy() || dev->is_blocked()) {
929             send_dir_busy_message(dir, dev);
930          } else {                     /* device not being used */
931             autochanger_cmd(dcr, dir, cmd);
932          }
933          V(dev->mutex);
934          free_dcr(dcr);
935          jcr->dcr = NULL;
936       } else {
937          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
938       }
939    } else {  /* error on scanf */
940       pm_strcpy(jcr->errmsg, dir->msg);
941       bnet_fsend(dir, _("3908 Error scanning autocharger drives/list/slots command: %s\n"),
942          jcr->errmsg);
943    }
944    bnet_sig(dir, BNET_EOD);
945    return true;
946 }
947
948 /*
949  * Read and return the Volume label
950  */
951 static bool readlabel_cmd(JCR *jcr)
952 {
953    POOL_MEM devname;
954    BSOCK *dir = jcr->dir_bsock;
955    DEVICE *dev;
956    DCR *dcr;
957    int Slot;
958    int drive;
959
960    if (sscanf(dir->msg, "readlabel %127s Slot=%d drive=%d", devname.c_str(), 
961        &Slot, &drive) == 3) {
962       dcr = find_device(jcr, devname, drive);
963       if (dcr) {
964          dev = dcr->dev;
965          P(dev->mutex);               /* Use P to avoid indefinite block */
966          if (!dev->is_open()) {
967             read_volume_label(jcr, dev, Slot);
968             dev->close();
969          /* Under certain "safe" conditions, we can steal the lock */
970          } else if (dev->can_steal_lock()) {
971             read_volume_label(jcr, dev, Slot);
972          } else if (dev->is_busy() || dev->is_blocked()) {
973             send_dir_busy_message(dir, dev);
974          } else {                     /* device not being used */
975             read_volume_label(jcr, dev, Slot);
976          }
977          V(dev->mutex);
978          free_dcr(dcr);
979          jcr->dcr = NULL;
980       } else {
981          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
982       }
983    } else {
984       pm_strcpy(jcr->errmsg, dir->msg);
985       bnet_fsend(dir, _("3909 Error scanning readlabel command: %s\n"), jcr->errmsg);
986    }
987    bnet_sig(dir, BNET_EOD);
988    return true;
989 }
990
991
992 /*
993  * Read the tape label
994  *
995  *  Enter with the mutex set
996  */
997 static void read_volume_label(JCR *jcr, DEVICE *dev, int Slot)
998 {
999    BSOCK *dir = jcr->dir_bsock;
1000    bsteal_lock_t hold;
1001    DCR *dcr = jcr->dcr;
1002
1003    dcr->dev = dev;
1004    steal_device_lock(dev, &hold, BST_WRITING_LABEL);
1005
1006    if (!try_autoload_device(jcr, Slot, "")) {
1007       goto bail_out;                  /* error */
1008    }
1009
1010    dev->clear_labeled();              /* force read of label */
1011    switch (read_dev_volume_label(dcr)) {
1012    case VOL_OK:
1013       /* DO NOT add quotes around the Volume name. It is scanned in the DIR */
1014       bnet_fsend(dir, _("3001 Volume=%s Slot=%d\n"), dev->VolHdr.VolumeName, Slot);
1015       Dmsg1(100, "Volume: %s\n", dev->VolHdr.VolumeName);
1016       break;
1017    default:
1018       bnet_fsend(dir, _("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
1019                  dev->print_name(), jcr->errmsg);
1020       break;
1021    }
1022
1023 bail_out:
1024    give_back_device_lock(dev, &hold);
1025    return;
1026 }
1027
1028 static bool try_autoload_device(JCR *jcr, int slot, const char *VolName)
1029 {
1030    DCR *dcr = jcr->dcr;
1031    BSOCK *dir = jcr->dir_bsock;
1032
1033    bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
1034    dcr->VolCatInfo.Slot = slot;
1035    dcr->VolCatInfo.InChanger = slot > 0;
1036    if (autoload_device(dcr, 0, dir) < 0) {    /* autoload if possible */
1037       return false;
1038    }
1039    return true;
1040 }
1041
1042 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev)
1043 {
1044    if (dev->is_blocked()) {
1045       switch (dev->dev_blocked) {
1046       case BST_UNMOUNTED:
1047          bnet_fsend(dir, _("3931 Device %s is BLOCKED. user unmounted.\n"),
1048             dev->print_name());
1049          break;
1050       case BST_UNMOUNTED_WAITING_FOR_SYSOP:
1051          bnet_fsend(dir, _("3932 Device %s is BLOCKED. user unmounted during wait for media/mount.\n"),
1052              dev->print_name());
1053          break;
1054       case BST_WAITING_FOR_SYSOP:
1055          bnet_fsend(dir, _("3933 Device %s is BLOCKED waiting for media.\n"),
1056             dev->print_name());
1057          break;
1058       case BST_DOING_ACQUIRE:
1059          bnet_fsend(dir, _("3934 Device %s is being initialized.\n"),
1060             dev->print_name());
1061          break;
1062       case BST_WRITING_LABEL:
1063          bnet_fsend(dir, _("3935 Device %s is blocked labeling a Volume.\n"),
1064             dev->print_name());
1065          break;
1066       default:
1067          bnet_fsend(dir, _("3935 Device %s is blocked for unknown reason.\n"),
1068             dev->print_name());
1069          break;
1070       }
1071    } else if (dev->can_read()) {
1072        bnet_fsend(dir, _("3936 Device %s is busy reading.\n"),
1073                    dev->print_name());;
1074    } else {
1075        bnet_fsend(dir, _("3937 Device %s is busy with %d writer(s).\n"),
1076           dev->print_name(), dev->num_writers);
1077    }
1078 }