]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/dird/ua_output.c
Fix dynamic file options
[bacula/bacula] / bacula / src / dird / ua_output.c
1 /*
2  *
3  *   Bacula Director -- User Agent Output Commands
4  *     I.e. messages, listing database, showing resources, ...
5  *
6  *     Kern Sibbald, September MM
7  *
8  *   Version $Id$
9  */
10
11 /*
12    Copyright (C) 2000-2003 Kern Sibbald and John Walker
13
14    This program is free software; you can redistribute it and/or
15    modify it under the terms of the GNU General Public License as
16    published by the Free Software Foundation; either version 2 of
17    the License, or (at your option) any later version.
18
19    This program is distributed in the hope that it will be useful,
20    but WITHOUT ANY WARRANTY; without even the implied warranty of
21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22    General Public License for more details.
23
24    You should have received a copy of the GNU General Public
25    License along with this program; if not, write to the Free
26    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
27    MA 02111-1307, USA.
28
29  */
30
31 #include "bacula.h"
32 #include "dird.h"
33 #include "ua.h"
34
35 /* Imported subroutines */
36 extern void run_job(JCR *jcr);
37
38 /* Imported variables */
39 extern int r_first;
40 extern int r_last;
41 extern struct s_res resources[];
42 extern int console_msg_pending;
43 extern FILE *con_fd;
44 extern brwlock_t con_lock;
45
46
47 /* Imported functions */
48
49 /* Forward referenced functions */
50
51
52 /*
53  * Turn auto display of console messages on/off
54  */
55 int autodisplaycmd(UAContext *ua, char *cmd)
56 {
57    static char *kw[] = {
58       N_("on"), 
59       N_("off"),
60       NULL};
61
62    switch (find_arg_keyword(ua, kw)) {
63       case 0:
64          ua->auto_display_messages = 1;
65          break;
66       case 1:
67          ua->auto_display_messages = 0;
68          break;
69       default:
70          bsendmsg(ua, _("ON or OFF keyword missing.\n"));
71          break;
72    }
73    return 1; 
74 }
75
76
77 struct showstruct {char *res_name; int type;};
78 static struct showstruct reses[] = {
79    {N_("directors"),  R_DIRECTOR},
80    {N_("clients"),    R_CLIENT},
81    {N_("jobs"),       R_JOB},
82    {N_("storages"),   R_STORAGE},
83    {N_("catalogs"),   R_CATALOG},
84    {N_("schedules"),  R_SCHEDULE},
85    {N_("filesets"),   R_FILESET},
86    {N_("groups"),     R_GROUP},
87    {N_("pools"),      R_POOL},
88    {N_("messages"),   R_MSGS},
89    {N_("all"),        -1},
90    {N_("help"),       -2},
91    {NULL,           0}
92 };
93
94
95 /*
96  *  Displays Resources
97  *
98  *  show all
99  *  show <resource-keyword-name>  e.g. show directors
100  *  show <resource-keyword-name>=<name> e.g. show director=HeadMan
101  *
102  */
103 int showcmd(UAContext *ua, char *cmd)
104 {
105    int i, j, type, len; 
106    int recurse;
107    char *res_name;
108    RES *res = NULL;
109
110    Dmsg1(20, "show: %s\n", ua->UA_sock->msg);
111
112
113    for (i=1; i<ua->argc; i++) {
114       type = 0;
115       res_name = ua->argk[i]; 
116       if (!ua->argv[i]) {             /* was a name given? */
117          /* No name, dump all resources of specified type */
118          recurse = 1;
119          len = strlen(res_name);
120          for (j=0; reses[j].res_name; j++) {
121             if (strncasecmp(res_name, _(reses[j].res_name), len) == 0) {
122                type = reses[j].type;
123                if (type > 0) {
124                   res = resources[type-r_first].res_head;
125                } else {
126                   res = NULL;
127                }
128                break;
129             }
130          }
131       } else {
132          /* Dump a single resource with specified name */
133          recurse = 0;
134          len = strlen(res_name);
135          for (j=0; reses[j].res_name; j++) {
136             if (strncasecmp(res_name, _(reses[j].res_name), len) == 0) {
137                type = reses[j].type;
138                res = (RES *)GetResWithName(type, ua->argv[i]);
139                if (!res) {
140                   type = -3;
141                }
142                break;
143             }
144          }
145       }
146
147       switch (type) {
148       case -1:                           /* all */
149          for (j=r_first; j<=r_last; j++) {
150             dump_resource(j, resources[j-r_first].res_head, bsendmsg, ua);     
151          }
152          break;
153       case -2:
154          bsendmsg(ua, _("Keywords for the show command are:\n"));
155          for (j=0; reses[j].res_name; j++) {
156             bsendmsg(ua, "%s\n", _(reses[j].res_name));
157          }
158          return 1;
159       case -3:
160          bsendmsg(ua, _("%s resource %s not found.\n"), res_name, ua->argv[i]);
161          return 1;
162       case 0:
163          bsendmsg(ua, _("Resource %s not found\n"), res_name);
164          return 1;
165       default:
166          dump_resource(recurse?type:-type, res, bsendmsg, ua);
167          break;
168       }
169    }
170    return 1;
171 }
172
173
174
175
176 /*
177  *  List contents of database
178  *
179  *  list jobs           - lists all jobs run
180  *  list jobid=nnn      - list job data for jobid
181  *  list job=name       - list job data for job
182  *  list jobmedia jobid=<nn>
183  *  list jobmedia job=name
184  *  list files jobid=<nn> - list files saved for job nn
185  *  list files job=name
186  *  list pools          - list pool records
187  *  list jobtotals      - list totals for all jobs
188  *  list media          - list media for given pool
189  *  list clients        - list clients
190  *
191  */
192 int listcmd(UAContext *ua, char *cmd) 
193 {
194    POOLMEM *VolumeName;
195    int jobid, n;
196    int i, j;
197    JOB_DBR jr;
198    POOL_DBR pr;
199    MEDIA_DBR mr;
200
201    if (!open_db(ua))
202       return 1;
203
204    memset(&jr, 0, sizeof(jr));
205    memset(&pr, 0, sizeof(pr));
206    memset(&mr, 0, sizeof(mr));
207
208    Dmsg1(20, "list: %s\n", cmd);
209
210    if (!ua->db) {
211       bsendmsg(ua, _("Hey! DB is NULL\n"));
212    }
213
214    /* Scan arguments looking for things to do */
215    for (i=1; i<ua->argc; i++) {
216       /* List JOBS */
217       if (strcasecmp(ua->argk[i], _("jobs")) == 0) {
218          db_list_job_records(ua->db, &jr, prtit, ua);
219
220          /* List JOBTOTALS */
221       } else if (strcasecmp(ua->argk[i], _("jobtotals")) == 0) {
222          db_list_job_totals(ua->db, &jr, prtit, ua);
223
224       /* List JOBID */
225       } else if (strcasecmp(ua->argk[i], _("jobid")) == 0) {
226          if (ua->argv[i]) {
227             jobid = atoi(ua->argv[i]);
228             if (jobid > 0) {
229                jr.JobId = jobid;
230                db_list_job_records(ua->db, &jr, prtit, ua);
231             }
232          }
233
234       /* List JOB */
235       } else if (strcasecmp(ua->argk[i], _("job")) == 0 && ua->argv[i]) {
236          bstrncpy(jr.Job, ua->argv[i], MAX_NAME_LENGTH);
237          jr.JobId = 0;
238          db_list_job_records(ua->db, &jr, prtit, ua);
239
240       /* List FILES */
241       } else if (strcasecmp(ua->argk[i], _("files")) == 0) {
242
243          for (j=i+1; j<ua->argc; j++) {
244             if (strcasecmp(ua->argk[j], _("job")) == 0 && ua->argv[j]) {
245                bstrncpy(jr.Job, ua->argv[j], MAX_NAME_LENGTH);
246                jr.JobId = 0;
247                db_get_job_record(ua->db, &jr);
248                jobid = jr.JobId;
249             } else if (strcasecmp(ua->argk[j], _("jobid")) == 0 && ua->argv[j]) {
250                jobid = atoi(ua->argv[j]);
251             } else {
252                continue;
253             }
254             if (jobid > 0) {
255                db_list_files_for_job(ua->db, jobid, prtit, ua);
256             }
257          }
258       
259       /* List JOBMEDIA */
260       } else if (strcasecmp(ua->argk[i], _("jobmedia")) == 0) {
261          int done = FALSE;
262          for (j=i+1; j<ua->argc; j++) {
263             if (strcasecmp(ua->argk[j], _("job")) == 0 && ua->argv[j]) {
264                bstrncpy(jr.Job, ua->argv[j], MAX_NAME_LENGTH);
265                jr.JobId = 0;
266                db_get_job_record(ua->db, &jr);
267                jobid = jr.JobId;
268             } else if (strcasecmp(ua->argk[j], _("jobid")) == 0 && ua->argv[j]) {
269                jobid = atoi(ua->argv[j]);
270             } else {
271                continue;
272             }
273             db_list_jobmedia_records(ua->db, jobid, prtit, ua);
274             done = TRUE;
275          }
276          if (!done) {
277             /* List for all jobs (jobid=0) */
278             db_list_jobmedia_records(ua->db, 0, prtit, ua);
279          }
280
281       /* List POOLS */
282       } else if (strcasecmp(ua->argk[i], _("pools")) == 0) {
283          db_list_pool_records(ua->db, prtit, ua);
284
285       } else if (strcasecmp(ua->argk[i], _("clients")) == 0) {
286          db_list_client_records(ua->db, prtit, ua);
287
288
289       /* List MEDIA or VOLUMES */
290       } else if (strcasecmp(ua->argk[i], _("media")) == 0 ||
291                  strcasecmp(ua->argk[i], _("volumes")) == 0) {
292          int done = FALSE;
293          for (j=i+1; j<ua->argc; j++) {
294             if (strcasecmp(ua->argk[j], _("job")) == 0 && ua->argv[j]) {
295                bstrncpy(jr.Job, ua->argv[j], MAX_NAME_LENGTH);
296                jr.JobId = 0;
297                db_get_job_record(ua->db, &jr);
298                jobid = jr.JobId;
299             } else if (strcasecmp(ua->argk[j], _("jobid")) == 0 && ua->argv[j]) {
300                jobid = atoi(ua->argv[j]);
301             } else {
302                continue;
303             }
304             VolumeName = get_pool_memory(PM_FNAME);
305             n = db_get_job_volume_names(ua->db, jobid, &VolumeName);
306             bsendmsg(ua, _("Jobid %d used %d Volume(s): %s\n"), jobid, n, VolumeName);
307             free_pool_memory(VolumeName);
308             done = TRUE;
309          }
310          /* if no job or jobid keyword found, then we list all media */
311          if (!done) {
312             if (!get_pool_dbr(ua, &pr)) {
313                return 1;
314             }
315             mr.PoolId = pr.PoolId;
316             db_list_media_records(ua->db, &mr, prtit, ua);
317          }
318       } else {
319          bsendmsg(ua, _("Unknown list keyword: %s\n"), NPRT(ua->argk[i]));
320       }
321    }
322    return 1;
323 }
324
325 static void con_lock_release(void *arg)
326 {
327    Vw(con_lock);
328 }
329
330 void do_messages(UAContext *ua, char *cmd)
331 {
332    char msg[2000];
333    int mlen; 
334    int do_truncate = FALSE;
335
336    Pw(con_lock);
337    pthread_cleanup_push(con_lock_release, (void *)NULL);
338    rewind(con_fd);
339    while (fgets(msg, sizeof(msg), con_fd)) {
340       mlen = strlen(msg);
341       ua->UA_sock->msg = check_pool_memory_size(ua->UA_sock->msg, mlen+1);
342       strcpy(ua->UA_sock->msg, msg);
343       ua->UA_sock->msglen = mlen;
344       bnet_send(ua->UA_sock);
345       do_truncate = TRUE;
346    }
347    if (do_truncate) {
348       ftruncate(fileno(con_fd), 0L);
349    }
350    console_msg_pending = FALSE;
351    ua->user_notified_msg_pending = FALSE;
352    pthread_cleanup_pop(0);
353    Vw(con_lock);
354 }
355
356
357 int qmessagescmd(UAContext *ua, char *cmd)
358 {
359    if (console_msg_pending && ua->auto_display_messages) {
360       do_messages(ua, cmd);
361    }
362    return 1;
363 }
364
365 int messagescmd(UAContext *ua, char *cmd)
366 {
367    if (console_msg_pending) {
368       do_messages(ua, cmd);
369    } else {
370       bnet_fsend(ua->UA_sock, _("You have no messages.\n"));
371    }
372    return 1;
373 }
374
375 /*
376  * Callback routine for "printing" database file listing
377  */
378 void prtit(void *ctx, char *msg)
379 {
380    UAContext *ua = (UAContext *)ctx;
381  
382    bnet_fsend(ua->UA_sock, "%s", msg);
383 }
384
385 /* 
386  * Format message and send to other end.  
387
388  * If the UA_sock is NULL, it means that there is no user
389  * agent, so we are being called from Bacula core. In
390  * that case direct the messages to the Job.
391  */
392 void bsendmsg(void *ctx, char *fmt, ...)
393 {
394    va_list arg_ptr;
395    UAContext *ua = (UAContext *)ctx;
396    BSOCK *bs = ua->UA_sock;
397    int maxlen, len;
398    POOLMEM *msg;
399
400    if (bs) {
401       msg = bs->msg;
402    } else {
403       msg = get_pool_memory(PM_EMSG);
404    }
405
406 again:
407    maxlen = sizeof_pool_memory(msg) - 1;
408    va_start(arg_ptr, fmt);
409    len = bvsnprintf(msg, maxlen, fmt, arg_ptr);
410    va_end(arg_ptr);
411    if (len < 0 || len >= maxlen) {
412       msg = realloc_pool_memory(msg, maxlen + 200);
413       goto again;
414    }
415
416    if (bs) {
417       bs->msglen = len;
418       bnet_send(bs);
419    } else {                           /* No UA, send to Job */
420       Jmsg(ua->jcr, M_INFO, 0, msg);
421       free_pool_memory(msg);
422    }
423
424 }