git.sur5r.net Git - bacula/bacula/blob - bacula/src/tray-monitor/tray_conf.c

   1 /*
   2 *   Main configuration file parser for Bacula Tray Monitor.
   3 *
   4 *   Adapted from dird_conf.c
   5 *
   6 *   Note, the configuration file parser consists of three parts
   7 *
   8 *   1. The generic lexical scanner in lib/lex.c and lib/lex.h
   9 *
  10 *   2. The generic config  scanner in lib/parse_config.c and
  11 *       lib/parse_config.h.
  12 *       These files contain the parser code, some utility
  13 *       routines, and the common store routines (name, int,
  14 *       string).
  15 *
  16 *   3. The daemon specific file, which contains the Resource
  17 *       definitions as well as any specific store routines
  18 *       for the resource records.
  19 *
  20 *     Nicolas Boichat, August MMIV
  21 *
  22 *     Version $Id$
  23 */
  24 /*
  25    Copyright (C) 2004 Kern Sibbald and John Walker
  26
  27    This program is free software; you can redistribute it and/or
  28    modify it under the terms of the GNU General Public License as
  29    published by the Free Software Foundation; either version 2 of
  30    the License, or (at your option) any later version.
  31
  32    This program is distributed in the hope that it will be useful,
  33    but WITHOUT ANY WARRANTY; without even the implied warranty of
  34    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  35    General Public License for more details.
  36
  37    You should have received a copy of the GNU General Public
  38    License along with this program; if not, write to the Free
  39    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  40    MA 02111-1307, USA.
  41
  42 */
  43
  44 #include "bacula.h"
  45 #include "tray_conf.h"
  46
  47 /* Define the first and last resource ID record
  48 * types. Note, these should be unique for each
  49 * daemon though not a requirement.
  50 */
  51 int r_first = R_FIRST;
  52 int r_last  = R_LAST;
  53 static RES *sres_head[R_LAST - R_FIRST + 1];
  54 RES **res_head = sres_head;
  55
  56 /* We build the current resource here as we are
  57 * scanning the resource configuration definition,
  58 * then move it to allocated memory when the resource
  59 * scan is complete.
  60 */
  61 URES res_all;
  62 int  res_all_size = sizeof(res_all);
  63
  64
  65 /* Definition of records permitted within each
  66 * resource with the routine to process the record
  67 * information.  NOTE! quoted names must be in lower case.
  68 */
  69 /*
  70 *    Monitor Resource
  71 *
  72 *   name           handler     value                 code flags    default_value
  73 */
  74 static RES_ITEM mon_items[] = {
  75    {"name",        store_name,     ITEM(res_monitor.hdr.name), 0, ITEM_REQUIRED, 0},
  76    {"description", store_str,      ITEM(res_monitor.hdr.desc), 0, 0, 0},
  77    {"requiressl",  store_yesno,    ITEM(res_monitor.require_ssl), 1, ITEM_DEFAULT, 0},
  78    {"password",    store_password, ITEM(res_monitor.password), 0, ITEM_REQUIRED, 0},
  79    {"refreshinterval",  store_time,ITEM(res_monitor.RefreshInterval),  0, ITEM_DEFAULT, 5},
  80    {"fdconnecttimeout", store_time,ITEM(res_monitor.FDConnectTimeout), 0, ITEM_DEFAULT, 60 * 30},
  81    {"sdconnecttimeout", store_time,ITEM(res_monitor.SDConnectTimeout), 0, ITEM_DEFAULT, 60 * 30},
  82    {NULL, NULL, NULL, 0, 0, 0}
  83 };
  84
  85 /*  Director's that we can contact */
  86 static RES_ITEM dir_items[] = {
  87    {"name",        store_name,     ITEM(res_dir.hdr.name), 0, ITEM_REQUIRED, 0},
  88    {"description", store_str,      ITEM(res_dir.hdr.desc), 0, 0, 0},
  89    {"dirport",     store_int,      ITEM(res_dir.DIRport),  0, ITEM_DEFAULT, 9101},
  90    {"address",     store_str,      ITEM(res_dir.address),  0, 0, 0},
  91    {"enablessl",   store_yesno,    ITEM(res_dir.enable_ssl), 1, ITEM_DEFAULT, 0},
  92    {NULL, NULL, NULL, 0, 0, 0}
  93 };
  94
  95 /*
  96 *    Client or File daemon resource
  97 *
  98 *   name           handler     value                 code flags    default_value
  99 */
 100
 101 static RES_ITEM cli_items[] = {
 102    {"name",     store_name,       ITEM(res_client.hdr.name), 0, ITEM_REQUIRED, 0},
 103    {"description", store_str,     ITEM(res_client.hdr.desc), 0, 0, 0},
 104    {"address",  store_str,        ITEM(res_client.address),  0, ITEM_REQUIRED, 0},
 105    {"fdport",   store_pint,       ITEM(res_client.FDport),   0, ITEM_DEFAULT, 9102},
 106    {"password", store_password,   ITEM(res_client.password), 0, ITEM_REQUIRED, 0},
 107    {"enablessl", store_yesno,     ITEM(res_client.enable_ssl), 1, ITEM_DEFAULT, 0},
 108    {NULL, NULL, NULL, 0, 0, 0}
 109 };
 110
 111 /* Storage daemon resource
 112 *
 113 *   name           handler     value                 code flags    default_value
 114 */
 115 static RES_ITEM store_items[] = {
 116    {"name",        store_name,     ITEM(res_store.hdr.name),   0, ITEM_REQUIRED, 0},
 117    {"description", store_str,      ITEM(res_store.hdr.desc),   0, 0, 0},
 118    {"sdport",      store_pint,     ITEM(res_store.SDport),     0, ITEM_DEFAULT, 9103},
 119    {"address",     store_str,      ITEM(res_store.address),    0, ITEM_REQUIRED, 0},
 120    {"sdaddress",   store_str,      ITEM(res_store.address),    0, 0, 0},
 121    {"password",    store_password, ITEM(res_store.password),   0, ITEM_REQUIRED, 0},
 122    {"sdpassword",  store_password, ITEM(res_store.password),   0, 0, 0},
 123    {"enablessl",   store_yesno,    ITEM(res_store.enable_ssl),  1, ITEM_DEFAULT, 0},
 124    {NULL, NULL, NULL, 0, 0, 0}
 125 };
 126
 127 /*
 128 * This is the master resource definition.
 129 * It must have one item for each of the resources.
 130 *
 131 *  NOTE!!! keep it in the same order as the R_codes
 132 *    or eliminate all resources[rindex].name
 133 *
 134 *  name      items        rcode        res_head
 135 */
 136 RES_TABLE resources[] = {
 137    {"monitor",      mon_items,    R_MONITOR},
 138    {"director",     dir_items,    R_DIRECTOR},
 139    {"client",       cli_items,    R_CLIENT},
 140    {"storage",      store_items,  R_STORAGE},
 141    {NULL,           NULL,         0}
 142 };
 143
 144 /* Dump contents of resource */
 145 void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fmt, ...), void *sock)
 146 {
 147    URES *res = (URES *)reshdr;
 148    bool recurse = true;
 149    char ed1[100], ed2[100];
 150
 151    if (res == NULL) {
 152       sendit(sock, "No %s resource defined\n", res_to_str(type));
 153       return;
 154    }
 155    if (type < 0) {                    /* no recursion */
 156       type = - type;
 157       recurse = false;
 158    }
 159    switch (type) {
 160    case R_MONITOR:
 161       sendit(sock, "Monitor: name=%s FDtimeout=%s SDtimeout=%s\n",
 162    reshdr->name,
 163    edit_uint64(res->res_monitor.FDConnectTimeout, ed1),
 164    edit_uint64(res->res_monitor.SDConnectTimeout, ed2));
 165       break;
 166    case R_DIRECTOR:
 167       sendit(sock, "Director: name=%s address=%s FDport=%d\n",
 168    res->res_dir.hdr.name, res->res_dir.address, res->res_dir.DIRport);
 169       break;
 170    case R_CLIENT:
 171       sendit(sock, "Client: name=%s address=%s FDport=%d\n",
 172    res->res_client.hdr.name, res->res_client.address, res->res_client.FDport);
 173       break;
 174    case R_STORAGE:
 175       sendit(sock, "Storage: name=%s address=%s SDport=%d\n",
 176    res->res_store.hdr.name, res->res_store.address, res->res_store.SDport);
 177       break;
 178    default:
 179       sendit(sock, "Unknown resource type %d in dump_resource.\n", type);
 180       break;
 181    }
 182    if (recurse && res->res_monitor.hdr.next) {
 183       dump_resource(type, res->res_monitor.hdr.next, sendit, sock);
 184    }
 185 }
 186
 187
 188 /*
 189 * Free memory of resource -- called when daemon terminates.
 190 * NB, we don't need to worry about freeing any references
 191 * to other resources as they will be freed when that
 192 * resource chain is traversed.  Mainly we worry about freeing
 193 * allocated strings (names).
 194 */
 195 void free_resource(RES *sres, int type)
 196 {
 197    RES *nres;                         /* next resource if linked */
 198    URES *res = (URES *)sres;
 199
 200    if (res == NULL)
 201       return;
 202
 203    /* common stuff -- free the resource name and description */
 204    nres = (RES *)res->res_monitor.hdr.next;
 205    if (res->res_monitor.hdr.name) {
 206       free(res->res_monitor.hdr.name);
 207    }
 208    if (res->res_monitor.hdr.desc) {
 209       free(res->res_monitor.hdr.desc);
 210    }
 211
 212    switch (type) {
 213    case R_MONITOR:
 214       break;
 215    case R_CLIENT:
 216       if (res->res_client.address) {
 217    free(res->res_client.address);
 218       }
 219       if (res->res_client.password) {
 220    free(res->res_client.password);
 221       }
 222       break;
 223    case R_STORAGE:
 224       if (res->res_store.address) {
 225    free(res->res_store.address);
 226       }
 227       if (res->res_store.password) {
 228    free(res->res_store.password);
 229       }
 230       break;
 231    default:
 232       printf("Unknown resource type %d in free_resource.\n", type);
 233    }
 234    /* Common stuff again -- free the resource, recurse to next one */
 235    if (res) {
 236       free(res);
 237    }
 238    if (nres) {
 239       free_resource(nres, type);
 240    }
 241 }
 242
 243 /*
 244 * Save the new resource by chaining it into the head list for
 245 * the resource. If this is pass 2, we update any resource
 246 * pointers because they may not have been defined until
 247 * later in pass 1.
 248 */
 249 void save_resource(int type, RES_ITEM *items, int pass)
 250 {
 251    URES *res;
 252    int rindex = type - r_first;
 253    int i, size;
 254    int error = 0;
 255
 256    /*
 257    * Ensure that all required items are present
 258    */
 259    for (i=0; items[i].name; i++) {
 260       if (items[i].flags & ITEM_REQUIRED) {
 261          if (!bit_is_set(i, res_all.res_monitor.hdr.item_present)) {
 262                Emsg2(M_ERROR_TERM, 0, "%s item is required in %s resource, but not found.\n",
 263                   items[i].name, resources[rindex]);
 264          }
 265       }
 266       /* If this triggers, take a look at lib/parse_conf.h */
 267       if (i >= MAX_RES_ITEMS) {
 268          Emsg1(M_ERROR_TERM, 0, "Too many items in %s resource\n", resources[rindex]);
 269       }
 270    }
 271
 272    /*
 273    * During pass 2 in each "store" routine, we looked up pointers
 274    * to all the resources referrenced in the current resource, now we
 275    * must copy their addresses from the static record to the allocated
 276    * record.
 277    */
 278    if (pass == 2) {
 279       switch (type) {
 280       /* Resources not containing a resource */
 281       case R_MONITOR:
 282       case R_CLIENT:
 283       case R_STORAGE:
 284       case R_DIRECTOR:
 285          break;
 286       default:
 287          Emsg1(M_ERROR, 0, "Unknown resource type %d in save_resource.\n", type);
 288          error = 1;
 289          break;
 290       }
 291       /* Note, the resource name was already saved during pass 1,
 292       * so here, we can just release it.
 293       */
 294       if (res_all.res_monitor.hdr.name) {
 295          free(res_all.res_monitor.hdr.name);
 296          res_all.res_monitor.hdr.name = NULL;
 297       }
 298       if (res_all.res_monitor.hdr.desc) {
 299          free(res_all.res_monitor.hdr.desc);
 300          res_all.res_monitor.hdr.desc = NULL;
 301       }
 302       return;
 303    }
 304
 305    /*
 306    * The following code is only executed during pass 1
 307    */
 308    switch (type) {
 309    case R_MONITOR:
 310       size = sizeof(MONITOR);
 311       break;
 312    case R_DIRECTOR:
 313       size = sizeof(DIRRES);
 314       break;
 315    case R_CLIENT:
 316       size = sizeof(CLIENT);
 317       break;
 318    case R_STORAGE:
 319       size = sizeof(STORE);
 320       break;
 321    default:
 322       printf("Unknown resource type %d in save_resrouce.\n", type);
 323       error = 1;
 324       size = 1;
 325       break;
 326    }
 327    /* Common */
 328    if (!error) {
 329       res = (URES *)malloc(size);
 330       memcpy(res, &res_all, size);
 331       if (!res_head[rindex]) {
 332    res_head[rindex] = (RES *)res; /* store first entry */
 333          Dmsg3(900, "Inserting first %s res: %s index=%d\n", res_to_str(type),
 334          res->res_monitor.hdr.name, rindex);
 335       } else {
 336    RES *next;
 337    /* Add new res to end of chain */
 338    for (next=res_head[rindex]; next->next; next=next->next) {
 339       if (strcmp(next->name, res->res_monitor.hdr.name) == 0) {
 340          Emsg2(M_ERROR_TERM, 0,
 341                   _("Attempt to define second %s resource named \"%s\" is not permitted.\n"),
 342          resources[rindex].name, res->res_monitor.hdr.name);
 343       }
 344    }
 345    next->next = (RES *)res;
 346          Dmsg4(900, "Inserting %s res: %s index=%d pass=%d\n", res_to_str(type),
 347          res->res_monitor.hdr.name, rindex, pass);
 348       }
 349    }
 350 }