git.sur5r.net Git - bacula/bacula/blob - 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-2004 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
  34 /* Imported subroutines */
  35
  36 /* Imported variables */
  37 extern int r_first;
  38 extern int r_last;
  39 extern RES_TABLE resources[];
  40 extern RES **res_head;
  41 extern int console_msg_pending;
  42 extern FILE *con_fd;
  43 extern brwlock_t con_lock;
  44
  45 /* Imported functions */
  46
  47 /* Forward referenced functions */
  48 static int do_list_cmd(UAContext *ua, const char *cmd, e_list_type llist);
  49 static bool list_nextvol(UAContext *ua);
  50
  51 /*
  52  * Turn auto display of console messages on/off
  53  */
  54 int autodisplay_cmd(UAContext *ua, const char *cmd)
  55 {
  56    static const char *kw[] = {
  57       N_("on"),
  58       N_("off"),
  59       NULL};
  60
  61    switch (find_arg_keyword(ua, kw)) {
  62    case 0:
  63       ua->auto_display_messages = 1;
  64       break;
  65    case 1:
  66       ua->auto_display_messages = 0;
  67       break;
  68    default:
  69       bsendmsg(ua, _("ON or OFF keyword missing.\n"));
  70       break;
  71    }
  72    return 1;
  73 }
  74
  75 /*
  76  * Turn batch processing on/off
  77  */
  78 int gui_cmd(UAContext *ua, const char *cmd)
  79 {
  80    static const char *kw[] = {
  81       N_("on"),
  82       N_("off"),
  83       NULL};
  84
  85    switch (find_arg_keyword(ua, kw)) {
  86    case 0:
  87       ua->batch = true;
  88       ua->jcr->gui = true;
  89       break;
  90    case 1:
  91       ua->batch = false;
  92       ua->jcr->gui = false;
  93       break;
  94    default:
  95       bsendmsg(ua, _("ON or OFF keyword missing.\n"));
  96       break;
  97    }
  98    return 1;
  99 }
 100
 101
 102
 103 struct showstruct {const char *res_name; int type;};
 104 static struct showstruct reses[] = {
 105    {N_("directors"),  R_DIRECTOR},
 106    {N_("clients"),    R_CLIENT},
 107    {N_("counters"),   R_COUNTER},
 108    {N_("devices"),    R_DEVICE},
 109    {N_("jobs"),       R_JOB},
 110    {N_("storages"),   R_STORAGE},
 111    {N_("catalogs"),   R_CATALOG},
 112    {N_("schedules"),  R_SCHEDULE},
 113    {N_("filesets"),   R_FILESET},
 114    {N_("pools"),      R_POOL},
 115    {N_("messages"),   R_MSGS},
 116    {N_("all"),        -1},
 117    {N_("help"),       -2},
 118    {NULL,           0}
 119 };
 120
 121
 122 /*
 123  *  Displays Resources
 124  *
 125  *  show all
 126  *  show <resource-keyword-name>  e.g. show directors
 127  *  show <resource-keyword-name>=<name> e.g. show director=HeadMan
 128  *
 129  */
 130 int show_cmd(UAContext *ua, const char *cmd)
 131 {
 132    int i, j, type, len;
 133    int recurse;
 134    char *res_name;
 135    RES *res = NULL;
 136
 137    Dmsg1(20, "show: %s\n", ua->UA_sock->msg);
 138
 139
 140    LockRes();
 141    for (i=1; i<ua->argc; i++) {
 142       type = 0;
 143       res_name = ua->argk[i];
 144       if (!ua->argv[i]) {             /* was a name given? */
 145          /* No name, dump all resources of specified type */
 146          recurse = 1;
 147          len = strlen(res_name);
 148          for (j=0; reses[j].res_name; j++) {
 149             if (strncasecmp(res_name, _(reses[j].res_name), len) == 0) {
 150                type = reses[j].type;
 151                if (type > 0) {
 152                   res = res_head[type-r_first];
 153                } else {
 154                   res = NULL;
 155                }
 156                break;
 157             }
 158          }
 159
 160       } else {
 161          /* Dump a single resource with specified name */
 162          recurse = 0;
 163          len = strlen(res_name);
 164          for (j=0; reses[j].res_name; j++) {
 165             if (strncasecmp(res_name, _(reses[j].res_name), len) == 0) {
 166                type = reses[j].type;
 167                res = (RES *)GetResWithName(type, ua->argv[i]);
 168                if (!res) {
 169                   type = -3;
 170                }
 171                break;
 172             }
 173          }
 174       }
 175
 176       switch (type) {
 177       case -1:                           /* all */
 178          for (j=r_first; j<=r_last; j++) {
 179             dump_resource(j, res_head[j-r_first], bsendmsg, ua);
 180          }
 181          break;
 182       case -2:
 183          bsendmsg(ua, _("Keywords for the show command are:\n"));
 184          for (j=0; reses[j].res_name; j++) {
 185             bsendmsg(ua, "%s\n", _(reses[j].res_name));
 186          }
 187          goto bail_out;
 188       case -3:
 189          bsendmsg(ua, _("%s resource %s not found.\n"), res_name, ua->argv[i]);
 190          goto bail_out;
 191       case 0:
 192          bsendmsg(ua, _("Resource %s not found\n"), res_name);
 193          goto bail_out;
 194       default:
 195          dump_resource(recurse?type:-type, res, bsendmsg, ua);
 196          break;
 197       }
 198    }
 199 bail_out:
 200    UnlockRes();
 201    return 1;
 202 }
 203
 204
 205
 206
 207 /*
 208  *  List contents of database
 209  *
 210  *  list jobs           - lists all jobs run
 211  *  list jobid=nnn      - list job data for jobid
 212  *  list job=name       - list job data for job
 213  *  list jobmedia jobid=<nn>
 214  *  list jobmedia job=name
 215  *  list files jobid=<nn> - list files saved for job nn
 216  *  list files job=name
 217  *  list pools          - list pool records
 218  *  list jobtotals      - list totals for all jobs
 219  *  list media          - list media for given pool (deprecated)
 220  *  list volumes        - list Volumes
 221  *  list clients        - list clients
 222  *  list nextvol job=xx  - list the next vol to be used by job
 223  *  list nextvolume job=xx - same as above.
 224  *
 225  */
 226
 227 /* Do long or full listing */
 228 int llist_cmd(UAContext *ua, const char *cmd)
 229 {
 230    return do_list_cmd(ua, cmd, VERT_LIST);
 231 }
 232
 233 /* Do short or summary listing */
 234 int list_cmd(UAContext *ua, const char *cmd)
 235 {
 236    return do_list_cmd(ua, cmd, HORZ_LIST);
 237 }
 238
 239 static int do_list_cmd(UAContext *ua, const char *cmd, e_list_type llist)
 240 {
 241    POOLMEM *VolumeName;
 242    int jobid, n;
 243    int i, j;
 244    JOB_DBR jr;
 245    POOL_DBR pr;
 246    MEDIA_DBR mr;
 247
 248    if (!open_db(ua))
 249       return 1;
 250
 251    memset(&jr, 0, sizeof(jr));
 252    memset(&pr, 0, sizeof(pr));
 253    memset(&mr, 0, sizeof(mr));
 254
 255    Dmsg1(20, "list: %s\n", cmd);
 256
 257    if (!ua->db) {
 258       bsendmsg(ua, _("Hey! DB is NULL\n"));
 259    }
 260
 261    /* Scan arguments looking for things to do */
 262    for (i=1; i<ua->argc; i++) {
 263       /* List JOBS */
 264       if (strcasecmp(ua->argk[i], _("jobs")) == 0) {
 265          db_list_job_records(ua->jcr, ua->db, &jr, prtit, ua, llist);
 266
 267          /* List JOBTOTALS */
 268       } else if (strcasecmp(ua->argk[i], _("jobtotals")) == 0) {
 269          db_list_job_totals(ua->jcr, ua->db, &jr, prtit, ua);
 270
 271       /* List JOBID */
 272       } else if (strcasecmp(ua->argk[i], _("jobid")) == 0) {
 273          if (ua->argv[i]) {
 274             jobid = str_to_int64(ua->argv[i]);
 275             if (jobid > 0) {
 276                jr.JobId = jobid;
 277                db_list_job_records(ua->jcr, ua->db, &jr, prtit, ua, llist);
 278             }
 279          }
 280
 281       /* List JOB */
 282       } else if (strcasecmp(ua->argk[i], _("job")) == 0 && ua->argv[i]) {
 283          bstrncpy(jr.Job, ua->argv[i], MAX_NAME_LENGTH);
 284          jr.JobId = 0;
 285          db_list_job_records(ua->jcr, ua->db, &jr, prtit, ua, llist);
 286
 287       /* List FILES */
 288       } else if (strcasecmp(ua->argk[i], _("files")) == 0) {
 289
 290          for (j=i+1; j<ua->argc; j++) {
 291             if (strcasecmp(ua->argk[j], _("job")) == 0 && ua->argv[j]) {
 292                bstrncpy(jr.Job, ua->argv[j], MAX_NAME_LENGTH);
 293                jr.JobId = 0;
 294                db_get_job_record(ua->jcr, ua->db, &jr);
 295                jobid = jr.JobId;
 296             } else if (strcasecmp(ua->argk[j], _("jobid")) == 0 && ua->argv[j]) {
 297                jobid = str_to_int64(ua->argv[j]);
 298             } else {
 299                continue;
 300             }
 301             if (jobid > 0) {
 302                db_list_files_for_job(ua->jcr, ua->db, jobid, prtit, ua);
 303             }
 304          }
 305
 306       /* List JOBMEDIA */
 307       } else if (strcasecmp(ua->argk[i], _("jobmedia")) == 0) {
 308          int done = FALSE;
 309          for (j=i+1; j<ua->argc; j++) {
 310             if (strcasecmp(ua->argk[j], _("job")) == 0 && ua->argv[j]) {
 311                bstrncpy(jr.Job, ua->argv[j], MAX_NAME_LENGTH);
 312                jr.JobId = 0;
 313                db_get_job_record(ua->jcr, ua->db, &jr);
 314                jobid = jr.JobId;
 315             } else if (strcasecmp(ua->argk[j], _("jobid")) == 0 && ua->argv[j]) {
 316                jobid = str_to_int64(ua->argv[j]);
 317             } else {
 318                continue;
 319             }
 320             db_list_jobmedia_records(ua->jcr, ua->db, jobid, prtit, ua, llist);
 321             done = TRUE;
 322          }
 323          if (!done) {
 324             /* List for all jobs (jobid=0) */
 325             db_list_jobmedia_records(ua->jcr, ua->db, 0, prtit, ua, llist);
 326          }
 327
 328       /* List POOLS */
 329       } else if (strcasecmp(ua->argk[i], _("pools")) == 0) {
 330          db_list_pool_records(ua->jcr, ua->db, prtit, ua, llist);
 331
 332       } else if (strcasecmp(ua->argk[i], _("clients")) == 0) {
 333          db_list_client_records(ua->jcr, ua->db, prtit, ua, llist);
 334
 335
 336       /* List MEDIA or VOLUMES */
 337       } else if (strcasecmp(ua->argk[i], _("media")) == 0 ||
 338                  strcasecmp(ua->argk[i], _("volumes")) == 0) {
 339          bool done = false;
 340          for (j=i+1; j<ua->argc; j++) {
 341             if (strcasecmp(ua->argk[j], _("job")) == 0 && ua->argv[j]) {
 342                bstrncpy(jr.Job, ua->argv[j], MAX_NAME_LENGTH);
 343                jr.JobId = 0;
 344                db_get_job_record(ua->jcr, ua->db, &jr);
 345                jobid = jr.JobId;
 346             } else if (strcasecmp(ua->argk[j], _("jobid")) == 0 && ua->argv[j]) {
 347                jobid = str_to_int64(ua->argv[j]);
 348             } else {
 349                continue;
 350             }
 351             VolumeName = get_pool_memory(PM_FNAME);
 352             n = db_get_job_volume_names(ua->jcr, ua->db, jobid, &VolumeName);
 353             bsendmsg(ua, _("Jobid %d used %d Volume(s): %s\n"), jobid, n, VolumeName);
 354             free_pool_memory(VolumeName);
 355             done = true;
 356          }
 357          /* if no job or jobid keyword found, then we list all media */
 358          if (!done) {
 359             int num_pools;
 360             uint32_t *ids;
 361             /* Is a specific pool wanted? */
 362             for (i=1; i<ua->argc; i++) {
 363                if (strcasecmp(ua->argk[i], _("pool")) == 0) {
 364                   if (!get_pool_dbr(ua, &pr)) {
 365                      bsendmsg(ua, _("No Pool specified.\n"));
 366                      return 1;
 367                   }
 368                   mr.PoolId = pr.PoolId;
 369                   db_list_media_records(ua->jcr, ua->db, &mr, prtit, ua, llist);
 370                   return 1;
 371                }
 372             }
 373             /* List Volumes in all pools */
 374             if (!db_get_pool_ids(ua->jcr, ua->db, &num_pools, &ids)) {
 375                bsendmsg(ua, _("Error obtaining pool ids. ERR=%s\n"),
 376                         db_strerror(ua->db));
 377                return 1;
 378             }
 379             if (num_pools <= 0) {
 380                return 1;
 381             }
 382             for (i=0; i < num_pools; i++) {
 383                pr.PoolId = ids[i];
 384                if (db_get_pool_record(ua->jcr, ua->db, &pr)) {
 385                   bsendmsg(ua, _("Pool: %s\n"), pr.Name);
 386                }
 387                mr.PoolId = ids[i];
 388                db_list_media_records(ua->jcr, ua->db, &mr, prtit, ua, llist);
 389             }
 390             free(ids);
 391             return 1;
 392          }
 393       /* List a specific volume */
 394       } else if (strcasecmp(ua->argk[i], _("volume")) == 0) {
 395          if (!ua->argv[i]) {
 396             bsendmsg(ua, _("No Volume Name specified.\n"));
 397             return 1;
 398          }
 399          bstrncpy(mr.VolumeName, ua->argv[i], sizeof(mr.VolumeName));
 400          db_list_media_records(ua->jcr, ua->db, &mr, prtit, ua, llist);
 401          return 1;
 402       /* List next volume */
 403       } else if (strcasecmp(ua->argk[i], _("nextvol")) == 0 ||
 404                  strcasecmp(ua->argk[i], _("nextvolume")) == 0) {
 405          list_nextvol(ua);
 406       } else {
 407          bsendmsg(ua, _("Unknown list keyword: %s\n"), NPRT(ua->argk[i]));
 408       }
 409    }
 410    return 1;
 411 }
 412
 413 static bool list_nextvol(UAContext *ua)
 414 {
 415    JOB *job;
 416    JCR *jcr = ua->jcr;
 417    POOL *pool;
 418    RUN *run;
 419    time_t runtime;
 420    bool found = false;
 421    MEDIA_DBR mr;
 422
 423    memset(&mr, 0, sizeof(mr));
 424    mr.PoolId = jcr->PoolId;
 425    int i = find_arg_with_value(ua, "job");
 426    if (i <= 0) {
 427       if ((job = select_job_resource(ua)) == NULL) {
 428          return false;
 429       }
 430    } else {
 431       job = (JOB *)GetResWithName(R_JOB, ua->argv[i]);
 432       if (!job) {
 433          Jmsg(jcr, M_ERROR, 0, _("%s is not a job name.\n"), ua->argv[i]);
 434          if ((job = select_job_resource(ua)) == NULL) {
 435             return false;
 436          }
 437       }
 438    }
 439    for (run=NULL; (run = find_next_run(run, job, runtime)); ) {
 440       pool = run ? run->pool : NULL;
 441       if (!complete_jcr_for_job(jcr, job, pool)) {
 442          return false;
 443       }
 444
 445       if (!find_next_volume_for_append(jcr, &mr, 0)) {
 446          bsendmsg(ua, _("Could not find next Volume.\n"));
 447       } else {
 448          bsendmsg(ua, _("The next Volume to be used by Job \"%s\" will be %s\n"),
 449             job->hdr.name, mr.VolumeName);
 450          found = true;
 451       }
 452       if (jcr->db && jcr->db != ua->db) {
 453          db_close_database(jcr, jcr->db);
 454          jcr->db = NULL;
 455       }
 456    }
 457    if (!found) {
 458       bsendmsg(ua, _("Could not find next Volume.\n"));
 459       return false;
 460    }
 461    return true;
 462 }
 463
 464
 465 /*
 466  * For a given job, we examine all his run records
 467  *  to see if it is scheduled today or tomorrow.
 468  */
 469 RUN *find_next_run(RUN *run, JOB *job, time_t &runtime)
 470 {
 471    time_t now, tomorrow;
 472    SCHED *sched;
 473    struct tm tm;
 474    int mday, wday, month, wom, tmday, twday, tmonth, twom, i;
 475    int woy, twoy;
 476    int tod, tom;
 477
 478    sched = job->schedule;
 479    if (sched == NULL) {            /* scheduled? */
 480       return NULL;                 /* no nothing to report */
 481    }
 482    /* Break down current time into components */
 483    now = time(NULL);
 484    localtime_r(&now, &tm);
 485    mday = tm.tm_mday - 1;
 486    wday = tm.tm_wday;
 487    month = tm.tm_mon;
 488    wom = mday / 7;
 489    woy = tm_woy(now);
 490
 491    /* Break down tomorrow into components */
 492    tomorrow = now + 60 * 60 * 24;
 493    localtime_r(&tomorrow, &tm);
 494    tmday = tm.tm_mday - 1;
 495    twday = tm.tm_wday;
 496    tmonth = tm.tm_mon;
 497    twom = tmday / 7;
 498    twoy  = tm_woy(tomorrow);
 499
 500    if (run == NULL) {
 501       run = sched->run;
 502    } else {
 503       run = run->next;
 504    }
 505    for ( ; run; run=run->next) {
 506       /*
 507        * Find runs in next 24 hours
 508        */
 509       tod = bit_is_set(mday, run->mday) && bit_is_set(wday, run->wday) &&
 510             bit_is_set(month, run->month) && bit_is_set(wom, run->wom) &&
 511             bit_is_set(woy, run->woy);
 512
 513       tom = bit_is_set(tmday, run->mday) && bit_is_set(twday, run->wday) &&
 514             bit_is_set(tmonth, run->month) && bit_is_set(twom, run->wom) &&
 515             bit_is_set(twoy, run->woy);
 516
 517 #ifdef xxx
 518       Dmsg2(000, "tod=%d tom=%d\n", tod, tom);
 519       Dmsg1(000, "bit_set_mday=%d\n", bit_is_set(mday, run->mday));
 520       Dmsg1(000, "bit_set_wday=%d\n", bit_is_set(wday, run->wday));
 521       Dmsg1(000, "bit_set_month=%d\n", bit_is_set(month, run->month));
 522       Dmsg1(000, "bit_set_wom=%d\n", bit_is_set(wom, run->wom));
 523       Dmsg1(000, "bit_set_woy=%d\n", bit_is_set(woy, run->woy));
 524 #endif
 525       if (tod) {                   /* Jobs scheduled today (next 24 hours) */
 526 #ifdef xxx
 527          char buf[300], num[10];
 528          bsnprintf(buf, sizeof(buf), "tm.hour=%d hour=", tm.tm_hour);
 529          for (i=0; i<24; i++) {
 530             if (bit_is_set(i, run->hour)) {
 531                bsnprintf(num, sizeof(num), "%d ", i);
 532                bstrncat(buf, num, sizeof(buf));
 533             }
 534          }
 535          bstrncat(buf, "\n", sizeof(buf));
 536          Dmsg1(000, "%s", buf);
 537 #endif
 538          /* find time (time_t) job is to be run */
 539          localtime_r(&now, &tm);
 540          for (i=tm.tm_hour; i < 24; i++) {
 541             if (bit_is_set(i, run->hour)) {
 542                tm.tm_hour = i;
 543                tm.tm_min = run->minute;
 544                tm.tm_sec = 0;
 545                runtime = mktime(&tm);
 546                Dmsg2(200, "now=%d runtime=%d\n", now, runtime);
 547                if (runtime > now) {
 548                   Dmsg2(200, "Found it level=%d %c\n", run->level, run->level);
 549                   return run;         /* found it, return run resource */
 550                }
 551             }
 552          }
 553       }
 554
 555 //    Dmsg2(200, "runtime=%d now=%d\n", runtime, now);
 556       if (tom) {                /* look at jobs scheduled tomorrow */
 557          localtime_r(&tomorrow, &tm);
 558          for (i=0; i < 24; i++) {
 559             if (bit_is_set(i, run->hour)) {
 560                tm.tm_hour = i;
 561                tm.tm_min = run->minute;
 562                tm.tm_sec = 0;
 563                runtime = mktime(&tm);
 564                Dmsg2(200, "now=%d runtime=%d\n", now, runtime);
 565                if (runtime < tomorrow) {
 566                   Dmsg2(200, "Found it level=%d %c\n", run->level, run->level);
 567                   return run;         /* found it, return run resource */
 568                }
 569             }
 570          }
 571       }
 572    } /* end for loop over runs */
 573    /* Nothing found */
 574    return NULL;
 575 }
 576 /*
 577  * Fill in the remaining fields of the jcr as if it
 578  *  is going to run the job.
 579  */
 580 int complete_jcr_for_job(JCR *jcr, JOB *job, POOL *pool)
 581 {
 582    POOL_DBR pr;
 583
 584    memset(&pr, 0, sizeof(POOL_DBR));
 585    set_jcr_defaults(jcr, job);
 586    if (pool) {
 587       jcr->pool = pool;               /* override */
 588    }
 589    jcr->db = jcr->db=db_init_database(jcr, jcr->catalog->db_name, jcr->catalog->db_user,
 590                       jcr->catalog->db_password, jcr->catalog->db_address,
 591                       jcr->catalog->db_port, jcr->catalog->db_socket,
 592                       jcr->catalog->mult_db_connections);
 593    if (!jcr->db || !db_open_database(jcr, jcr->db)) {
 594       Jmsg(jcr, M_FATAL, 0, _("Could not open database \"%s\".\n"),
 595                  jcr->catalog->db_name);
 596       if (jcr->db) {
 597          Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
 598       }
 599       return 0;
 600    }
 601    bstrncpy(pr.Name, jcr->pool->hdr.name, sizeof(pr.Name));
 602    while (!db_get_pool_record(jcr, jcr->db, &pr)) { /* get by Name */
 603       /* Try to create the pool */
 604       if (create_pool(jcr, jcr->db, jcr->pool, POOL_OP_CREATE) < 0) {
 605          Jmsg(jcr, M_FATAL, 0, _("Pool %s not in database. %s"), pr.Name,
 606             db_strerror(jcr->db));
 607          if (jcr->db) {
 608             db_close_database(jcr, jcr->db);
 609             jcr->db = NULL;
 610          }
 611          return 0;
 612       } else {
 613          Jmsg(jcr, M_INFO, 0, _("Pool %s created in database.\n"), pr.Name);
 614       }
 615    }
 616    jcr->PoolId = pr.PoolId;
 617    jcr->jr.PoolId = pr.PoolId;
 618    return 1;
 619 }
 620
 621
 622 static void con_lock_release(void *arg)
 623 {
 624    Vw(con_lock);
 625 }
 626
 627 void do_messages(UAContext *ua, const char *cmd)
 628 {
 629    char msg[2000];
 630    int mlen;
 631    int do_truncate = FALSE;
 632
 633    Pw(con_lock);
 634    pthread_cleanup_push(con_lock_release, (void *)NULL);
 635    rewind(con_fd);
 636    while (fgets(msg, sizeof(msg), con_fd)) {
 637       mlen = strlen(msg);
 638       ua->UA_sock->msg = check_pool_memory_size(ua->UA_sock->msg, mlen+1);
 639       strcpy(ua->UA_sock->msg, msg);
 640       ua->UA_sock->msglen = mlen;
 641       bnet_send(ua->UA_sock);
 642       do_truncate = TRUE;
 643    }
 644    if (do_truncate) {
 645       ftruncate(fileno(con_fd), 0L);
 646    }
 647    console_msg_pending = FALSE;
 648    ua->user_notified_msg_pending = FALSE;
 649    pthread_cleanup_pop(0);
 650    Vw(con_lock);
 651 }
 652
 653
 654 int qmessagescmd(UAContext *ua, const char *cmd)
 655 {
 656    if (console_msg_pending && ua->auto_display_messages) {
 657       do_messages(ua, cmd);
 658    }
 659    return 1;
 660 }
 661
 662 int messagescmd(UAContext *ua, const char *cmd)
 663 {
 664    if (console_msg_pending) {
 665       do_messages(ua, cmd);
 666    } else {
 667       bnet_fsend(ua->UA_sock, _("You have no messages.\n"));
 668    }
 669    return 1;
 670 }
 671
 672 /*
 673  * Callback routine for "printing" database file listing
 674  */
 675 void prtit(void *ctx, const char *msg)
 676 {
 677    UAContext *ua = (UAContext *)ctx;
 678
 679    bnet_fsend(ua->UA_sock, "%s", msg);
 680 }
 681
 682 /*
 683  * Format message and send to other end.
 684
 685  * If the UA_sock is NULL, it means that there is no user
 686  * agent, so we are being called from Bacula core. In
 687  * that case direct the messages to the Job.
 688  */
 689 void bsendmsg(void *ctx, const char *fmt, ...)
 690 {
 691    va_list arg_ptr;
 692    UAContext *ua = (UAContext *)ctx;
 693    BSOCK *bs = ua->UA_sock;
 694    int maxlen, len;
 695    POOLMEM *msg;
 696
 697    if (bs) {
 698       msg = bs->msg;
 699    } else {
 700       msg = get_pool_memory(PM_EMSG);
 701    }
 702
 703 again:
 704    maxlen = sizeof_pool_memory(msg) - 1;
 705    va_start(arg_ptr, fmt);
 706    len = bvsnprintf(msg, maxlen, fmt, arg_ptr);
 707    va_end(arg_ptr);
 708    if (len < 0 || len >= maxlen) {
 709       msg = realloc_pool_memory(msg, maxlen + maxlen/2);
 710       goto again;
 711    }
 712
 713    if (bs) {
 714       bs->msg = msg;
 715       bs->msglen = len;
 716       bnet_send(bs);
 717    } else {                           /* No UA, send to Job */
 718       Jmsg(ua->jcr, M_INFO, 0, "%s", msg);
 719       free_pool_memory(msg);
 720    }
 721
 722 }