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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2007 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of John Walker.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  *
  30  *   Bacula Director -- User Agent Server
  31  *
  32  *     Kern Sibbald, September MM
  33  *
  34  *    Version $Id$
  35  */
  36
  37 #include "bacula.h"
  38 #include "dird.h"
  39
  40 /* Imported variables */
  41 extern int r_first;
  42 extern int r_last;
  43 extern struct s_res resources[];
  44
  45
  46 /* Forward referenced functions */
  47 extern "C" void *connect_thread(void *arg);
  48 static void *handle_UA_client_request(void *arg);
  49
  50
  51 /* Global variables */
  52 static int started = FALSE;
  53 static workq_t ua_workq;
  54
  55 struct s_addr_port {
  56    char *addr;
  57    char *port;
  58 };
  59
  60 /* Called here by Director daemon to start UA (user agent)
  61  * command thread. This routine creates the thread and then
  62  * returns.
  63  */
  64 void start_UA_server(dlist *addrs)
  65 {
  66    pthread_t thid;
  67    int status;
  68    static dlist *myaddrs = addrs;
  69
  70    if ((status=pthread_create(&thid, NULL, connect_thread, (void *)myaddrs)) != 0) {
  71       berrno be;
  72       Emsg1(M_ABORT, 0, _("Cannot create UA thread: %s\n"), be.bstrerror(status));
  73    }
  74    started = TRUE;
  75    return;
  76 }
  77
  78 extern "C"
  79 void *connect_thread(void *arg)
  80 {
  81    pthread_detach(pthread_self());
  82
  83    /* Permit 20 console connections */
  84    bnet_thread_server((dlist*)arg, 20, &ua_workq, handle_UA_client_request);
  85    return NULL;
  86 }
  87
  88 /*
  89  * Create a Job Control Record for a control "job",
  90  *   filling in all the appropriate fields.
  91  */
  92 JCR *new_control_jcr(const char *base_name, int job_type)
  93 {
  94    JCR *jcr;
  95    jcr = new_jcr(sizeof(JCR), dird_free_jcr);
  96    /*
  97     * The job and defaults are not really used, but
  98     *  we set them up to ensure that everything is correctly
  99     *  initialized.
 100     */
 101    LockRes();
 102    jcr->job = (JOB *)GetNextRes(R_JOB, NULL);
 103    set_jcr_defaults(jcr, jcr->job);
 104    UnlockRes();
 105    jcr->sd_auth_key = bstrdup("dummy"); /* dummy Storage daemon key */
 106    create_unique_job_name(jcr, base_name);
 107    jcr->sched_time = jcr->start_time;
 108    jcr->JobType = job_type;
 109    jcr->JobLevel = L_NONE;
 110    set_jcr_job_status(jcr, JS_Running);
 111    jcr->JobId = 0;
 112    return jcr;
 113 }
 114
 115 /*
 116  * Handle Director User Agent commands
 117  *
 118  */
 119 static void *handle_UA_client_request(void *arg)
 120 {
 121    int stat;
 122    UAContext *ua;
 123    JCR *jcr;
 124    BSOCK *user = (BSOCK *)arg;
 125
 126    pthread_detach(pthread_self());
 127
 128    jcr = new_control_jcr("-Console-", JT_CONSOLE);
 129
 130    ua = new_ua_context(jcr);
 131    ua->UA_sock = user;
 132
 133    user->recv();             /* Get first message */
 134    if (!authenticate_user_agent(ua)) {
 135       goto getout;
 136    }
 137
 138    while (!ua->quit) {
 139       if (ua->api) user->signal(BNET_MAIN_PROMPT);
 140       stat = user->recv();
 141       if (stat >= 0) {
 142          pm_strcpy(ua->cmd, ua->UA_sock->msg);
 143          parse_ua_args(ua);
 144          if (ua->argc > 0 && ua->argk[0][0] == '.') {
 145             do_a_dot_command(ua);
 146          } else {
 147             do_a_command(ua);
 148          }
 149          dequeue_messages(ua->jcr);
 150          if (!ua->quit) {
 151             if (console_msg_pending && acl_access_ok(ua, Command_ACL, "messages", 8)) {
 152                if (ua->auto_display_messages) {
 153                   pm_strcpy(ua->cmd, "messages");
 154                   qmessagescmd(ua, ua->cmd);
 155                   ua->user_notified_msg_pending = false;
 156                } else if (!ua->gui && !ua->user_notified_msg_pending && console_msg_pending) {
 157                   if (ua->api) {
 158                      user->signal(BNET_MSGS_PENDING);
 159                   } else {
 160                      bsendmsg(ua, _("You have messages.\n"));
 161                   }
 162                   ua->user_notified_msg_pending = true;
 163                }
 164             }
 165             if (!ua->api) user->signal(BNET_EOD);     /* send end of command */
 166          }
 167       } else if (is_bnet_stop(user)) {
 168          ua->quit = true;
 169       } else { /* signal */
 170          user->signal(BNET_POLL);
 171       }
 172    }
 173
 174 getout:
 175    close_db(ua);
 176    free_ua_context(ua);
 177    free_jcr(jcr);
 178
 179    return NULL;
 180 }
 181
 182 /*
 183  * Create a UAContext for a Job that is running so that
 184  *   it can the User Agent routines and
 185  *   to ensure that the Job gets the proper output.
 186  *   This is a sort of mini-kludge, and should be
 187  *   unified at some point.
 188  */
 189 UAContext *new_ua_context(JCR *jcr)
 190 {
 191    UAContext *ua;
 192
 193    ua = (UAContext *)malloc(sizeof(UAContext));
 194    memset(ua, 0, sizeof(UAContext));
 195    ua->jcr = jcr;
 196    ua->db = jcr->db;
 197    ua->cmd = get_pool_memory(PM_FNAME);
 198    ua->args = get_pool_memory(PM_FNAME);
 199    ua->verbose = true;
 200    ua->automount = true;
 201    return ua;
 202 }
 203
 204 void free_ua_context(UAContext *ua)
 205 {
 206    if (ua->cmd) {
 207       free_pool_memory(ua->cmd);
 208    }
 209    if (ua->args) {
 210       free_pool_memory(ua->args);
 211    }
 212    if (ua->prompt) {
 213       free(ua->prompt);
 214    }
 215
 216    if (ua->UA_sock) {
 217       bnet_close(ua->UA_sock);
 218       ua->UA_sock = NULL;
 219    }
 220    free(ua);
 221 }
 222
 223
 224 /*
 225  * Called from main Bacula thread
 226  */
 227 void term_ua_server()
 228 {
 229    if (!started) {
 230       return;
 231    }
 232 }