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 three of the GNU Affero 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 Affero 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 Kern Sibbald.
  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
  42
  43 /* Forward referenced functions */
  44 extern "C" void *connect_thread(void *arg);
  45 static void *handle_UA_client_request(void *arg);
  46
  47
  48 /* Global variables */
  49 static int started = FALSE;
  50 static workq_t ua_workq;
  51
  52 struct s_addr_port {
  53    char *addr;
  54    char *port;
  55 };
  56
  57 /* Called here by Director daemon to start UA (user agent)
  58  * command thread. This routine creates the thread and then
  59  * returns.
  60  */
  61 void start_UA_server(dlist *addrs)
  62 {
  63    pthread_t thid;
  64    int status;
  65    static dlist *myaddrs = addrs;
  66
  67    if ((status=pthread_create(&thid, NULL, connect_thread, (void *)myaddrs)) != 0) {
  68       berrno be;
  69       Emsg1(M_ABORT, 0, _("Cannot create UA thread: %s\n"), be.bstrerror(status));
  70    }
  71    started = TRUE;
  72    return;
  73 }
  74
  75 extern "C"
  76 void *connect_thread(void *arg)
  77 {
  78    pthread_detach(pthread_self());
  79    set_jcr_in_tsd(INVALID_JCR);
  80
  81    /* Permit MaxConsoleConnect console connections */
  82    bnet_thread_server((dlist*)arg, director->MaxConsoleConnect, &ua_workq, handle_UA_client_request);
  83    return NULL;
  84 }
  85
  86 /*
  87  * Create a Job Control Record for a control "job",
  88  *   filling in all the appropriate fields.
  89  */
  90 JCR *new_control_jcr(const char *base_name, int job_type)
  91 {
  92    JCR *jcr;
  93    jcr = new_jcr(sizeof(JCR), dird_free_jcr);
  94    /*
  95     * The job and defaults are not really used, but
  96     *  we set them up to ensure that everything is correctly
  97     *  initialized.
  98     */
  99    LockRes();
 100    jcr->job = (JOB *)GetNextRes(R_JOB, NULL);
 101    set_jcr_defaults(jcr, jcr->job);
 102    UnlockRes();
 103    jcr->sd_auth_key = bstrdup("dummy"); /* dummy Storage daemon key */
 104    create_unique_job_name(jcr, base_name);
 105    jcr->sched_time = jcr->start_time;
 106    jcr->set_JobType(job_type);
 107    jcr->set_JobLevel(L_NONE);
 108    set_jcr_job_status(jcr, JS_Running);
 109    jcr->JobId = 0;
 110    return jcr;
 111 }
 112
 113 /*
 114  * Handle Director User Agent commands
 115  *
 116  */
 117 static void *handle_UA_client_request(void *arg)
 118 {
 119    int stat;
 120    UAContext *ua;
 121    JCR *jcr;
 122    BSOCK *user = (BSOCK *)arg;
 123
 124    pthread_detach(pthread_self());
 125
 126    jcr = new_control_jcr("-Console-", JT_CONSOLE);
 127
 128    ua = new_ua_context(jcr);
 129    ua->UA_sock = user;
 130    set_jcr_in_tsd(INVALID_JCR);
 131
 132    user->recv();             /* Get first message */
 133    if (!authenticate_user_agent(ua)) {
 134       goto getout;
 135    }
 136
 137    while (!ua->quit) {
 138       if (ua->api) user->signal(BNET_MAIN_PROMPT);
 139       stat = user->recv();
 140       if (stat >= 0) {
 141          pm_strcpy(ua->cmd, ua->UA_sock->msg);
 142          parse_ua_args(ua);
 143          if (ua->argc > 0 && ua->argk[0][0] == '.') {
 144             do_a_dot_command(ua);
 145          } else {
 146             do_a_command(ua);
 147          }
 148          dequeue_messages(ua->jcr);
 149          if (!ua->quit) {
 150             if (console_msg_pending && acl_access_ok(ua, Command_ACL, "messages", 8)) {
 151                if (ua->auto_display_messages) {
 152                   pm_strcpy(ua->cmd, "messages");
 153                   qmessagescmd(ua, ua->cmd);
 154                   ua->user_notified_msg_pending = false;
 155                } else if (!ua->gui && !ua->user_notified_msg_pending && console_msg_pending) {
 156                   if (ua->api) {
 157                      user->signal(BNET_MSGS_PENDING);
 158                   } else {
 159                      bsendmsg(ua, _("You have messages.\n"));
 160                   }
 161                   ua->user_notified_msg_pending = true;
 162                }
 163             }
 164             if (!ua->api) user->signal(BNET_EOD);     /* send end of command */
 165          }
 166       } else if (is_bnet_stop(user)) {
 167          ua->quit = true;
 168       } else { /* signal */
 169          user->signal(BNET_POLL);
 170       }
 171    }
 172
 173 getout:
 174    close_db(ua);
 175    free_ua_context(ua);
 176    free_jcr(jcr);
 177
 178    return NULL;
 179 }
 180
 181 /*
 182  * Create a UAContext for a Job that is running so that
 183  *   it can the User Agent routines and
 184  *   to ensure that the Job gets the proper output.
 185  *   This is a sort of mini-kludge, and should be
 186  *   unified at some point.
 187  */
 188 UAContext *new_ua_context(JCR *jcr)
 189 {
 190    UAContext *ua;
 191
 192    ua = (UAContext *)malloc(sizeof(UAContext));
 193    memset(ua, 0, sizeof(UAContext));
 194    ua->jcr = jcr;
 195    ua->db = jcr->db;
 196    ua->cmd = get_pool_memory(PM_FNAME);
 197    ua->args = get_pool_memory(PM_FNAME);
 198    ua->verbose = true;
 199    ua->automount = true;
 200    return ua;
 201 }
 202
 203 void free_ua_context(UAContext *ua)
 204 {
 205    if (ua->cmd) {
 206       free_pool_memory(ua->cmd);
 207    }
 208    if (ua->args) {
 209       free_pool_memory(ua->args);
 210    }
 211    if (ua->prompt) {
 212       free(ua->prompt);
 213    }
 214
 215    if (ua->UA_sock) {
 216       bnet_close(ua->UA_sock);
 217       ua->UA_sock = NULL;
 218    }
 219    free(ua);
 220 }
 221
 222
 223 /*
 224  * Called from main Bacula thread
 225  */
 226 void term_ua_server()
 227 {
 228    if (!started) {
 229       return;
 230    }
 231 }