git.gag.com Git - debian/amanda/blob - server-src/server_util.c

   1 /*
   2  * Amanda, The Advanced Maryland Automatic Network Disk Archiver
   3  * Copyright (c) 1991-1999 University of Maryland at College Park
   4  * All Rights Reserved.
   5  *
   6  * Permission to use, copy, modify, distribute, and sell this software and its
   7  * documentation for any purpose is hereby granted without fee, provided that
   8  * the above copyright notice appear in all copies and that both that
   9  * copyright notice and this permission notice appear in supporting
  10  * documentation, and that the name of U.M. not be used in advertising or
  11  * publicity pertaining to distribution of the software without specific,
  12  * written prior permission.  U.M. makes no representations about the
  13  * suitability of this software for any purpose.  It is provided "as is"
  14  * without express or implied warranty.
  15  *
  16  * U.M. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL U.M.
  18  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  20  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  21  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22  *
  23  * Authors: the Amanda Development Team.  Its members are listed in a
  24  * file named AUTHORS, in the root directory of this distribution.
  25  */
  26 /*
  27  * $Id: server_util.c,v 1.17 2006/05/25 01:47:20 johnfranks Exp $
  28  *
  29  */
  30
  31 #include "amanda.h"
  32 #include "server_util.h"
  33 #include "arglist.h"
  34 #include "logfile.h"
  35 #include "util.h"
  36 #include "conffile.h"
  37 #include "diskfile.h"
  38 #include "pipespawn.h"
  39 #include "conffile.h"
  40 #include "infofile.h"
  41 #include "sys/wait.h"
  42
  43 const char *cmdstr[] = {
  44     "BOGUS", "QUIT", "QUITTING", "DONE", "PARTIAL",
  45     "START", "FILE-DUMP", "PORT-DUMP", "CONTINUE", "ABORT",/* dumper cmds */
  46     "FAILED", "TRY-AGAIN", "NO-ROOM", "RQ-MORE-DISK",   /* dumper results */
  47     "ABORT-FINISHED", "BAD-COMMAND",                    /* dumper results */
  48     "START-TAPER", "FILE-WRITE", "NEW-TAPE", "NO-NEW-TAPE",
  49
  50     "PARTDONE", "PORT-WRITE", "DUMPER-STATUS",              /* taper cmds */
  51     "PORT", "TAPE-ERROR", "TAPER-OK",                    /* taper results */
  52     "REQUEST-NEW-TAPE", "DIRECTTCP-PORT",
  53     "LAST_TOK",
  54     NULL
  55 };
  56
  57
  58 struct cmdargs *
  59 getcmd(void)
  60 {
  61     char *line;
  62     cmd_t cmd_i;
  63     struct cmdargs *cmdargs = g_new0(struct cmdargs, 1);
  64
  65     if (isatty(0)) {
  66         g_printf("%s> ", get_pname());
  67         fflush(stdout);
  68         line = agets(stdin);
  69     } else {
  70         line = agets(stdin);
  71     }
  72     if (line == NULL) {
  73         line = stralloc("QUIT");
  74     }
  75
  76     dbprintf(_("getcmd: %s\n"), line);
  77
  78     cmdargs->argv = split_quoted_strings(line);
  79     cmdargs->argc = g_strv_length(cmdargs->argv);
  80     cmdargs->cmd = BOGUS;
  81
  82     amfree(line);
  83
  84     if (cmdargs->argc < 1) {
  85         return cmdargs;
  86     }
  87
  88     for(cmd_i=BOGUS; cmdstr[cmd_i] != NULL; cmd_i++)
  89         if(strcmp(cmdargs->argv[0], cmdstr[cmd_i]) == 0) {
  90             cmdargs->cmd = cmd_i;
  91             return cmdargs;
  92         }
  93     return cmdargs;
  94 }
  95
  96 struct cmdargs *
  97 get_pending_cmd(void)
  98 {
  99     SELECT_ARG_TYPE ready;
 100     struct timeval  to;
 101     int             nfound;
 102
 103     FD_ZERO(&ready);
 104     FD_SET(0, &ready);
 105     to.tv_sec = 0;
 106     to.tv_usec = 0;
 107
 108     nfound = select(1, &ready, NULL, NULL, &to);
 109     if (nfound && FD_ISSET(0, &ready)) {
 110         return getcmd();
 111     } else {
 112         return NULL;
 113     }
 114 }
 115
 116 void
 117 free_cmdargs(
 118     struct cmdargs *cmdargs)
 119 {
 120     if (!cmdargs)
 121         return;
 122     if (cmdargs->argv)
 123         g_strfreev(cmdargs->argv);
 124     g_free(cmdargs);
 125 }
 126
 127 printf_arglist_function1(void putresult, cmd_t, result, const char *, format)
 128 {
 129     va_list argp;
 130
 131     arglist_start(argp, format);
 132     dbprintf(_("putresult: %d %s\n"), result, cmdstr[result]);
 133     g_printf("%s ", cmdstr[result]);
 134     g_vprintf(format, argp);
 135     fflush(stdout);
 136     arglist_end(argp);
 137 }
 138
 139 char *
 140 amhost_get_security_conf(
 141     char *      string,
 142     void *      arg)
 143 {
 144     if(!string || !*string)
 145         return(NULL);
 146
 147     if(strcmp(string, "krb5principal")==0)
 148         return(getconf_str(CNF_KRB5PRINCIPAL));
 149     else if(strcmp(string, "krb5keytab")==0)
 150         return(getconf_str(CNF_KRB5KEYTAB));
 151
 152     if(!arg || !((am_host_t *)arg)->disks) return(NULL);
 153
 154     if(strcmp(string, "amandad_path")==0)
 155         return ((am_host_t *)arg)->disks->amandad_path;
 156     else if(strcmp(string, "client_username")==0)
 157         return ((am_host_t *)arg)->disks->client_username;
 158     else if(strcmp(string, "client_port")==0)
 159         return ((am_host_t *)arg)->disks->client_port;
 160     else if(strcmp(string, "ssh_keys")==0)
 161         return ((am_host_t *)arg)->disks->ssh_keys;
 162
 163     return(NULL);
 164 }
 165
 166 int check_infofile(
 167     char        *infodir,
 168     disklist_t  *dl,
 169     char       **errmsg)
 170 {
 171     disk_t      *dp, *diskp;
 172     char        *hostinfodir, *old_hostinfodir, *Xhostinfodir;
 173     char        *diskdir,     *old_diskdir,     *Xdiskdir;
 174     char        *infofile,    *old_infofile,    *Xinfofile;
 175     struct stat  statbuf;
 176     int other_dle_match;
 177
 178     if (stat(infodir, &statbuf) != 0) {
 179         return 0;
 180     }
 181
 182     for (dp = dl->head; dp != NULL; dp = dp->next) {
 183         hostinfodir = sanitise_filename(dp->host->hostname);
 184         diskdir     = sanitise_filename(dp->name);
 185         infofile = vstralloc(infodir, "/", hostinfodir, "/", diskdir,
 186                              "/info", NULL);
 187         if (stat(infofile, &statbuf) == -1 && errno == ENOENT) {
 188             old_hostinfodir = old_sanitise_filename(dp->host->hostname);
 189             old_diskdir     = old_sanitise_filename(dp->name);
 190             old_infofile    = vstralloc(infodir, old_hostinfodir, "/",
 191                                         old_diskdir, "/info", NULL);
 192             if (stat(old_infofile, &statbuf) == 0) {
 193                 other_dle_match = 0;
 194                 diskp = dl->head;
 195                 while (diskp != NULL) {
 196                     Xhostinfodir = sanitise_filename(diskp->host->hostname);
 197                     Xdiskdir     = sanitise_filename(diskp->name);
 198                     Xinfofile = vstralloc(infodir, "/", Xhostinfodir, "/",
 199                                           Xdiskdir, "/info", NULL);
 200                     if (strcmp(old_infofile, Xinfofile) == 0) {
 201                         other_dle_match = 1;
 202                         diskp = NULL;
 203                     }
 204                     else {
 205                         diskp = diskp->next;
 206                     }
 207                 }
 208                 if (other_dle_match == 0) {
 209                     if(mkpdir(infofile, (mode_t)0755, (uid_t)-1,
 210                               (gid_t)-1) == -1) {
 211                         *errmsg = vstralloc("Can't create directory for ",
 212                                             infofile, NULL);
 213                         return -1;
 214                     }
 215                     if(copy_file(infofile, old_infofile, errmsg) == -1)
 216                         return -1;
 217                 }
 218             }
 219         }
 220         amfree(diskdir);
 221         amfree(hostinfodir);
 222         amfree(infofile);
 223     }
 224     return 0;
 225 }
 226
 227 void
 228 run_server_script(
 229     pp_script_t  *pp_script,
 230     execute_on_t  execute_on,
 231     char         *config,
 232     disk_t       *dp,
 233     int           level)
 234 {
 235     pid_t      scriptpid;
 236     int        scriptin, scriptout, scripterr;
 237     char      *cmd;
 238     char      *command = NULL;
 239     GPtrArray *argv_ptr = g_ptr_array_new();
 240     FILE      *streamout;
 241     char      *line;
 242     char      *plugin;
 243     char       level_number[NUM_STR_SIZE];
 244
 245     if ((pp_script_get_execute_on(pp_script) & execute_on) == 0)
 246         return;
 247     if (pp_script_get_execute_where(pp_script) != ES_SERVER)
 248         return;
 249
 250     plugin = pp_script_get_plugin(pp_script);
 251     cmd = vstralloc(APPLICATION_DIR, "/", plugin, NULL);
 252     g_ptr_array_add(argv_ptr, stralloc(plugin));
 253
 254     switch (execute_on) {
 255     case EXECUTE_ON_PRE_DLE_AMCHECK:
 256         command = "PRE-DLE-AMCHECK";
 257         break;
 258     case EXECUTE_ON_PRE_HOST_AMCHECK:
 259         command = "PRE-HOST-AMCHECK";
 260         break;
 261     case EXECUTE_ON_POST_DLE_AMCHECK:
 262         command = "POST-DLE-AMCHECK";
 263         break;
 264     case EXECUTE_ON_POST_HOST_AMCHECK:
 265         command = "POST-HOST-AMCHECK";
 266         break;
 267     case EXECUTE_ON_PRE_DLE_ESTIMATE:
 268         command = "PRE-DLE-ESTIMATE";
 269         break;
 270     case EXECUTE_ON_PRE_HOST_ESTIMATE:
 271         command = "PRE-HOST-ESTIMATE";
 272         break;
 273     case EXECUTE_ON_POST_DLE_ESTIMATE:
 274         command = "POST-DLE-ESTIMATE";
 275         break;
 276     case EXECUTE_ON_POST_HOST_ESTIMATE:
 277         command = "POST-HOST-ESTIMATE";
 278         break;
 279     case EXECUTE_ON_PRE_DLE_BACKUP:
 280         command = "PRE-DLE-BACKUP";
 281         break;
 282     case EXECUTE_ON_PRE_HOST_BACKUP:
 283         command = "PRE-HOST-BACKUP";
 284         break;
 285     case EXECUTE_ON_POST_DLE_BACKUP:
 286         command = "POST-DLE-BACKUP";
 287         break;
 288     case EXECUTE_ON_POST_HOST_BACKUP:
 289         command = "POST-HOST-BACKUP";
 290         break;
 291     case EXECUTE_ON_PRE_RECOVER:
 292     case EXECUTE_ON_POST_RECOVER:
 293     case EXECUTE_ON_PRE_LEVEL_RECOVER:
 294     case EXECUTE_ON_POST_LEVEL_RECOVER:
 295     case EXECUTE_ON_INTER_LEVEL_RECOVER:
 296         {
 297              // ERROR these script can't be executed on server.
 298              return;
 299         }
 300     }
 301
 302     g_ptr_array_add(argv_ptr, stralloc(command));
 303     g_ptr_array_add(argv_ptr, stralloc("--execute-where"));
 304     g_ptr_array_add(argv_ptr, stralloc("server"));
 305
 306     if (config) {
 307         g_ptr_array_add(argv_ptr, stralloc("--config"));
 308         g_ptr_array_add(argv_ptr, stralloc(config));
 309     }
 310     if (dp->host->hostname) {
 311         g_ptr_array_add(argv_ptr, stralloc("--host"));
 312         g_ptr_array_add(argv_ptr, stralloc(dp->host->hostname));
 313     }
 314     if (dp->name) {
 315         g_ptr_array_add(argv_ptr, stralloc("--disk"));
 316         g_ptr_array_add(argv_ptr, stralloc(dp->name));
 317     }
 318     if (dp->device) {
 319         g_ptr_array_add(argv_ptr, stralloc("--device"));
 320         g_ptr_array_add(argv_ptr, stralloc(dp->device));
 321     }
 322     if (level >= 0) {
 323         g_snprintf(level_number, SIZEOF(level_number), "%d", level);
 324         g_ptr_array_add(argv_ptr, stralloc("--level"));
 325         g_ptr_array_add(argv_ptr, stralloc(level_number));
 326     }
 327
 328     property_add_to_argv(argv_ptr, pp_script_get_property(pp_script));
 329     g_ptr_array_add(argv_ptr, NULL);
 330
 331     scripterr = fileno(stderr);
 332     scriptpid = pipespawnv(cmd, STDIN_PIPE|STDOUT_PIPE, 0, &scriptin,
 333                            &scriptout, &scripterr,
 334                            (char **)argv_ptr->pdata);
 335     close(scriptin);
 336
 337     streamout = fdopen(scriptout, "r");
 338     if (streamout) {
 339         while((line = agets(streamout)) != NULL) {
 340             dbprintf("script: %s\n", line);
 341         }
 342     }
 343     fclose(streamout);
 344     waitpid(scriptpid, NULL, 0);
 345     g_ptr_array_free_full(argv_ptr);
 346 }
 347
 348
 349 void
 350 run_server_scripts(
 351     execute_on_t  execute_on,
 352     char         *config,
 353     disk_t       *dp,
 354     int           level)
 355 {
 356     identlist_t pp_scriptlist;
 357
 358     for (pp_scriptlist = dp->pp_scriptlist; pp_scriptlist != NULL;
 359          pp_scriptlist = pp_scriptlist->next) {
 360         pp_script_t *pp_script = lookup_pp_script((char *)pp_scriptlist->data);
 361         g_assert(pp_script != NULL);
 362         run_server_script(pp_script, execute_on, config, dp, level);
 363     }
 364 }
 365
 366 void
 367 run_amcleanup(
 368     char *config_name)
 369 {
 370     pid_t amcleanup_pid;
 371     char *amcleanup_program;
 372     char *amcleanup_options[4];
 373
 374     switch(amcleanup_pid = fork()) {
 375         case -1:
 376             return;
 377             break;
 378         case  0: /* child process */
 379             amcleanup_program = vstralloc(sbindir, "/", "amcleanup", NULL);
 380             amcleanup_options[0] = amcleanup_program;
 381             amcleanup_options[1] = "-p";
 382             amcleanup_options[2] = config_name;
 383             amcleanup_options[3] = NULL;
 384             execve(amcleanup_program, amcleanup_options, safe_env());
 385             error("exec %s: %s", amcleanup_program, strerror(errno));
 386             /*NOTREACHED*/
 387         default:
 388             break;
 389     }
 390     waitpid(amcleanup_pid, NULL, 0);
 391 }
 392
 393 char *
 394 get_master_process(
 395     char *logfile)
 396 {
 397     FILE *log;
 398     char line[1024];
 399     char *s, ch;
 400     char *process_name;
 401
 402     log = fopen(logfile, "r");
 403     if (!log)
 404         return stralloc("UNKNOWN");
 405
 406     while(fgets(line, 1024, log)) {
 407         if (strncmp_const(line, "INFO ") == 0) {
 408             s = line+5;
 409             ch = *s++;
 410             process_name = s-1;
 411             skip_non_whitespace(s, ch);
 412             s[-1] = '\0';
 413             skip_whitespace(s, ch);
 414             skip_non_whitespace(s, ch);
 415             s[-1] = '\0';
 416             skip_whitespace(s, ch);
 417             if (strncmp_const(s-1, "pid ") == 0) {
 418                 process_name = stralloc(process_name);
 419                 fclose(log);
 420                 return process_name;
 421             }
 422         }
 423     }
 424     fclose(log);
 425     return stralloc("UNKNOWN");
 426 }
 427
 428
 429 gint64
 430 internal_server_estimate(
 431     disk_t *dp,
 432     info_t *info,
 433     int     level,
 434     int    *stats)
 435 {
 436     int    j;
 437     gint64 size = 0;
 438
 439     *stats = 0;
 440
 441     if (level == 0) { /* use latest level 0, should do extrapolation */
 442         gint64 est_size = (gint64)0;
 443         int nb_est = 0;
 444
 445         for (j=NB_HISTORY-2; j>=0; j--) {
 446             if (info->history[j].level == 0) {
 447                 if (info->history[j].size < (gint64)0) continue;
 448                 est_size = info->history[j].size;
 449                 nb_est++;
 450             }
 451         }
 452         if (nb_est > 0) {
 453             size = est_size;
 454             *stats = 1;
 455         } else if (info->inf[level].size > (gint64)1000) { /* stats */
 456             size = info->inf[level].size;
 457             *stats = 1;
 458         } else {
 459             char *conf_tapetype = getconf_str(CNF_TAPETYPE);
 460             tapetype_t *tape = lookup_tapetype(conf_tapetype);
 461             size = (gint64)1000000;
 462             if (size > tapetype_get_length(tape)/2)
 463                 size = tapetype_get_length(tape)/2;
 464             *stats = 0;
 465         }
 466     } else if (level == info->last_level) {
 467         /* means of all X day at the same level */
 468         #define NB_DAY 30
 469         int nb_day = 0;
 470         gint64 est_size_day[NB_DAY];
 471         int nb_est_day[NB_DAY];
 472
 473         for (j=0; j<NB_DAY; j++) {
 474             est_size_day[j] = (gint64)0;
 475             nb_est_day[j] = 0;
 476         }
 477
 478         for (j=NB_HISTORY-2; j>=0; j--) {
 479             if (info->history[j].level <= 0) continue;
 480             if (info->history[j].size < (gint64)0) continue;
 481             if (info->history[j].level == info->history[j+1].level) {
 482                 if (nb_day <NB_DAY-1) nb_day++;
 483                 est_size_day[nb_day] += info->history[j].size;
 484                 nb_est_day[nb_day]++;
 485             } else {
 486                 nb_day=0;
 487             }
 488         }
 489         nb_day = info->consecutive_runs + 1;
 490         if (nb_day > NB_DAY-1) nb_day = NB_DAY-1;
 491
 492         while (nb_day > 0 && nb_est_day[nb_day] == 0) nb_day--;
 493
 494         if (nb_est_day[nb_day] > 0) {
 495             size = est_size_day[nb_day] / (gint64)nb_est_day[nb_day];
 496             *stats = 1;
 497         }
 498         else if (info->inf[level].size > (gint64)1000) { /* stats */
 499             size = info->inf[level].size;
 500             *stats = 1;
 501         }
 502         else {
 503             int level0_stat;
 504             gint64 level0_size;
 505             char *conf_tapetype = getconf_str(CNF_TAPETYPE);
 506             tapetype_t *tape = lookup_tapetype(conf_tapetype);
 507
 508             level0_size = internal_server_estimate(dp, info, 0, &level0_stat);
 509             size = (gint64)10000;
 510             if (size > tapetype_get_length(tape)/2)
 511                 size = tapetype_get_length(tape)/2;
 512             if (size > level0_size/2)
 513                 size = level0_size/2;
 514             *stats = 0;
 515         }
 516     }
 517     else if (level == info->last_level + 1) {
 518         /* means of all first day at a new level */
 519         gint64 est_size = (gint64)0;
 520         int nb_est = 0;
 521
 522         for (j=NB_HISTORY-2; j>=0; j--) {
 523             if (info->history[j].level <= 0) continue;
 524             if (info->history[j].size < (gint64)0) continue;
 525             if (info->history[j].level == info->history[j+1].level + 1 ) {
 526                 est_size += info->history[j].size;
 527                 nb_est++;
 528             }
 529         }
 530         if (nb_est > 0) {
 531             size = est_size / (gint64)nb_est;
 532             *stats = 1;
 533         } else if (info->inf[level].size > (gint64)1000) { /* stats */
 534             size = info->inf[level].size;
 535             *stats = 1;
 536         } else {
 537             int level0_stat;
 538             gint64 level0_size;
 539             char *conf_tapetype = getconf_str(CNF_TAPETYPE);
 540             tapetype_t *tape = lookup_tapetype(conf_tapetype);
 541
 542             level0_size = internal_server_estimate(dp, info, 0, &level0_stat);
 543             size = (gint64)100000;
 544             if (size > tapetype_get_length(tape)/2)
 545                 size = tapetype_get_length(tape)/2;
 546             if (size > level0_size/2)
 547                 size = level0_size/2;
 548             *stats = 0;
 549         }
 550     }
 551
 552     return size;
 553 }
 554
 555 int
 556 server_can_do_estimate(
 557     disk_t *dp,
 558     info_t *info,
 559     int     level)
 560 {
 561     gint64  size;
 562     int     stats;
 563
 564     size = internal_server_estimate(dp, info, level, &stats);
 565     return stats;
 566 }
 567