git.gag.com Git - debian/amanda/blob - common-src/fileheader.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: fileheader.c 6512 2007-05-24 17:00:24Z ian $
  28  */
  29
  30 #include "amanda.h"
  31 #include "fileheader.h"
  32 #include "match.h"
  33 #include <glib.h>
  34 #include "util.h"
  35
  36 static const char *     filetype2str(filetype_t);
  37 static filetype_t       str2filetype(const char *);
  38 static void             strange_header(dumpfile_t *, const char *,
  39                                 size_t, const char *, const char *);
  40 static char            *quote_heredoc(char *text, char *delimiter_prefix);
  41 static char            *parse_heredoc(char *line, char **saveptr);
  42
  43 void
  44 fh_init(
  45     dumpfile_t *file)
  46 {
  47     memset(file, '\0', SIZEOF(*file));
  48     file->type = F_EMPTY;
  49     file->blocksize = 0;
  50 }
  51
  52 static void
  53 strange_header(
  54     dumpfile_t *file,
  55     const char *buffer,
  56     size_t      buflen,
  57     const char *expected,
  58     const char *actual)
  59 {
  60     if (actual == NULL)
  61         actual = "<null>";
  62     if (expected == NULL)
  63         expected = "<null>";
  64
  65     g_debug("strange amanda header: \"%.*s\"", (int)buflen, buffer);
  66     g_debug("Expected: \"%s\"  Actual: \"%s\"", expected, actual);
  67
  68     file->type = F_WEIRD;
  69 }
  70
  71 /* chop whitespace off of a string, in place */
  72 static void
  73 chomp(char *str)
  74 {
  75     char *s = str;
  76
  77     if (!str)
  78         return;
  79
  80     /* trim leading space */
  81     while (g_ascii_isspace(*s)) { s++; }
  82     if (s != str)
  83         memmove(str, s, strlen(s)+1);
  84
  85     /* trim trailing space */
  86     if (*str) {
  87         for (s = str+strlen(str)-1; s >= str; s--) {
  88             if (!g_ascii_isspace(*s))
  89                 break;
  90             *s = '\0';
  91         }
  92     }
  93 }
  94
  95 void
  96 parse_file_header(
  97     const char *buffer,
  98     dumpfile_t *file,
  99     size_t      buflen)
 100 {
 101     char *buf, *line, *tok, *line1;
 102     size_t lsize;
 103     char *uqname;
 104     int in_quotes;
 105     char *saveptr = NULL;
 106
 107     /* put the buffer into a writable chunk of memory and nul-term it */
 108     buf = alloc(buflen + 1);
 109     memcpy(buf, buffer, buflen);
 110     buf[buflen] = '\0';
 111     fh_init(file);
 112
 113     /* extract the first unquoted line */
 114     in_quotes = 0;
 115     for (line = buf, lsize = 0; lsize < buflen; line++) {
 116         if ((*line == '\n') && !in_quotes)
 117             break;
 118
 119         if (*line == '"') {
 120             in_quotes = !in_quotes;
 121         } else if ((*line == '\\') && (*(line + 1) == '"')) {
 122             line++;
 123             lsize++;
 124         }
 125         lsize++;
 126     }
 127     *line = '\0';
 128     line1 = alloc(lsize + 1);
 129     strncpy(line1, buf, lsize);
 130     line1[lsize] = '\0';
 131     *line = '\n';
 132
 133     tok = strtok_r(line1, " ", &saveptr);
 134     if (tok == NULL) {
 135         g_debug("Empty amanda header: buflen=%zu lsize=%zu", buflen, lsize);
 136         strange_header(file, buffer, buflen, _("<Non-empty line>"), tok);
 137         goto out;
 138     }
 139
 140     if (strcmp(tok, "NETDUMP:") != 0 && strcmp(tok, "AMANDA:") != 0) {
 141         amfree(buf);
 142         file->type = F_UNKNOWN;
 143         amfree(line1);
 144         return;
 145     }
 146
 147     tok = strtok_r(NULL, " ", &saveptr);
 148     if (tok == NULL) {
 149         strange_header(file, buffer, buflen, _("<file type>"), tok);
 150         goto out;
 151     }
 152     file->type = str2filetype(tok);
 153
 154     switch (file->type) {
 155     case F_TAPESTART:
 156         tok = strtok_r(NULL, " ", &saveptr);
 157         if ((tok == NULL) || (strcmp(tok, "DATE") != 0)) {
 158             strange_header(file, buffer, buflen, "DATE", tok);
 159             goto out;
 160         }
 161
 162         tok = strtok_r(NULL, " ", &saveptr);
 163         if (tok == NULL) {
 164             strange_header(file, buffer, buflen, _("<date stamp>"), tok);
 165             goto out;
 166         }
 167         strncpy(file->datestamp, tok, SIZEOF(file->datestamp) - 1);
 168
 169         tok = strtok_r(NULL, " ", &saveptr);
 170         if ((tok == NULL) || (strcmp(tok, "TAPE") != 0)) {
 171             strange_header(file, buffer, buflen, "TAPE", tok);
 172             goto out;
 173         }
 174
 175         tok = strtok_r(NULL, " ", &saveptr);
 176         if (tok == NULL) {
 177             strange_header(file, buffer, buflen, _("<file type>"), tok);
 178             goto out;
 179         }
 180         strncpy(file->name, tok, SIZEOF(file->name) - 1);
 181         break;
 182
 183     case F_DUMPFILE:
 184     case F_CONT_DUMPFILE:
 185     case F_SPLIT_DUMPFILE:
 186         tok = strtok_r(NULL, " ", &saveptr);
 187         if (tok == NULL) {
 188             strange_header(file, buffer, buflen, _("<date stamp>"), tok);
 189             goto out;
 190         }
 191         strncpy(file->datestamp, tok, SIZEOF(file->datestamp) - 1);
 192
 193         tok = strtok_r(NULL, " ", &saveptr);
 194         if (tok == NULL) {
 195             strange_header(file, buffer, buflen, _("<file name>"), tok);
 196             goto out;
 197         }
 198         strncpy(file->name, tok, SIZEOF(file->name) - 1);
 199
 200         tok = strquotedstr(&saveptr);
 201         if (tok == NULL) {
 202             strange_header(file, buffer, buflen, _("<disk name>"), tok);
 203             goto out;
 204         }
 205         uqname = unquote_string(tok);
 206         strncpy(file->disk, uqname, SIZEOF(file->disk) - 1);
 207         amfree(uqname);
 208
 209         if(file->type == F_SPLIT_DUMPFILE) {
 210             tok = strtok_r(NULL, " ", &saveptr);
 211             if (tok == NULL || strcmp(tok, "part") != 0) {
 212                 strange_header(file, buffer, buflen, "part", tok);
 213                 goto out;
 214             }
 215
 216             tok = strtok_r(NULL, "/", &saveptr);
 217             if ((tok == NULL) || (sscanf(tok, "%d", &file->partnum) != 1)) {
 218                 strange_header(file, buffer, buflen, _("<part num param>"), tok);
 219                 goto out;
 220             }
 221
 222             /* If totalparts == -1, then the original dump was done in
 223                streaming mode (no holding disk), thus we don't know how
 224                many parts there are. */
 225             tok = strtok_r(NULL, " ", &saveptr);
 226             if((tok == NULL) || (sscanf(tok, "%d", &file->totalparts) != 1)) {
 227                 strange_header(file, buffer, buflen, _("<total parts param>"), tok);
 228                 goto out;
 229             }
 230         } else if (file->type == F_DUMPFILE) {
 231             /* only one part in this dump, so call it partnum 1 */
 232             file->partnum = 1;
 233             file->totalparts = 1;
 234         } else {
 235             file->partnum = 0;
 236             file->totalparts = 0;
 237         }
 238
 239         tok = strtok_r(NULL, " ", &saveptr);
 240         if ((tok == NULL) || (strcmp(tok, "lev") != 0)) {
 241             strange_header(file, buffer, buflen, "lev", tok);
 242             goto out;
 243         }
 244
 245         tok = strtok_r(NULL, " ", &saveptr);
 246         if ((tok == NULL) || (sscanf(tok, "%d", &file->dumplevel) != 1)) {
 247             strange_header(file, buffer, buflen, _("<dump level param>"), tok);
 248             goto out;
 249         }
 250
 251         tok = strtok_r(NULL, " ", &saveptr);
 252         if ((tok == NULL) || (strcmp(tok, "comp") != 0)) {
 253             strange_header(file, buffer, buflen, "comp", tok);
 254             goto out;
 255         }
 256
 257         tok = strtok_r(NULL, " ", &saveptr);
 258         if (tok == NULL) {
 259             strange_header(file, buffer, buflen, _("<comp param>"), tok);
 260             goto out;
 261         }
 262         strncpy(file->comp_suffix, tok, SIZEOF(file->comp_suffix) - 1);
 263
 264         file->compressed = (0 != strcmp(file->comp_suffix, "N"));
 265         if (file->compressed) {
 266             /* compatibility with pre-2.2 amanda */
 267             if (strcmp(file->comp_suffix, "C") == 0)
 268                 strncpy(file->comp_suffix, ".Z", SIZEOF(file->comp_suffix) - 1);
 269         } else {
 270             strcpy(file->comp_suffix, "");
 271         }
 272
 273         tok = strtok_r(NULL, " ", &saveptr);
 274         /* "program" is optional */
 275         if (tok == NULL || strcmp(tok, "program") != 0) {
 276             break;
 277         }
 278
 279         tok = strtok_r(NULL, " ", &saveptr);
 280         if (tok == NULL) {
 281             strange_header(file, buffer, buflen, _("<program name>"), tok);
 282             goto out;
 283         }
 284         strncpy(file->program, tok, SIZEOF(file->program) - 1);
 285
 286         if ((tok = strtok_r(NULL, " ", &saveptr)) == NULL)
 287              break;          /* reached the end of the buffer */
 288
 289         /* encryption is optional */
 290         if (BSTRNCMP(tok, "crypt") == 0) {
 291             tok = strtok_r(NULL, " ", &saveptr);
 292             if (tok == NULL) {
 293                 strange_header(file, buffer, buflen, _("<crypt param>"), tok);
 294                 goto out;
 295             }
 296             strncpy(file->encrypt_suffix, tok,
 297                     SIZEOF(file->encrypt_suffix) - 1);
 298             file->encrypted = 1;
 299
 300             /* for compatibility with who-knows-what, allow "comp N" to be
 301              * equivalent to no compression */
 302             if (0 == BSTRNCMP(file->encrypt_suffix, "N")) {
 303                 file->encrypted = 0;
 304                 strcpy(file->encrypt_suffix, "");
 305             }
 306
 307             if ((tok = strtok_r(NULL, " ", &saveptr)) == NULL)
 308                 break;
 309         }
 310
 311         /* "srvcompprog" is optional */
 312         if (BSTRNCMP(tok, "server_custom_compress") == 0) {
 313             tok = strtok_r(NULL, " ", &saveptr);
 314             if (tok == NULL) {
 315                 strange_header(file, buffer, buflen,
 316                                 _("<server custom compress param>"), tok);
 317                 goto out;
 318             }
 319             strncpy(file->srvcompprog, tok, SIZEOF(file->srvcompprog) - 1);
 320             if ((tok = strtok_r(NULL, " ", &saveptr)) == NULL)
 321                 break;
 322         }
 323
 324         /* "clntcompprog" is optional */
 325         if (BSTRNCMP(tok, "client_custom_compress") == 0) {
 326             tok = strtok_r(NULL, " ", &saveptr);
 327             if (tok == NULL) {
 328                 strange_header(file, buffer, buflen,
 329                                 _("<client custom compress param>"), tok);
 330                 goto out;
 331             }
 332             strncpy(file->clntcompprog, tok, SIZEOF(file->clntcompprog) - 1);
 333             if ((tok = strtok_r(NULL, " ", &saveptr)) == NULL)
 334                 break;
 335         }
 336
 337         /* "srv_encrypt" is optional */
 338         if (BSTRNCMP(tok, "server_encrypt") == 0) {
 339             tok = strtok_r(NULL, " ", &saveptr);
 340             if (tok == NULL) {
 341                 strange_header(file, buffer, buflen,
 342                                 _("<server encrypt param>"), tok);
 343                 goto out;
 344             }
 345             strncpy(file->srv_encrypt, tok, SIZEOF(file->srv_encrypt) - 1);
 346             if ((tok = strtok_r(NULL, " ", &saveptr)) == NULL)
 347                 break;
 348         }
 349
 350         /* "clnt_encrypt" is optional */
 351         if (BSTRNCMP(tok, "client_encrypt") == 0) {
 352             tok = strtok_r(NULL, " ", &saveptr);
 353             if (tok == NULL) {
 354                 strange_header(file, buffer, buflen,
 355                                 _("<client encrypt param>"), tok);
 356                 goto out;
 357             }
 358             strncpy(file->clnt_encrypt, tok, SIZEOF(file->clnt_encrypt) - 1);
 359             if ((tok = strtok_r(NULL, " ", &saveptr)) == NULL)
 360                 break;
 361         }
 362
 363         /* "srv_decrypt_opt" is optional */
 364         if (BSTRNCMP(tok, "server_decrypt_option") == 0) {
 365             tok = strtok_r(NULL, " ", &saveptr);
 366             if (tok == NULL) {
 367                 strange_header(file, buffer, buflen,
 368                                 _("<server decrypt param>"), tok);
 369                 goto out;
 370             }
 371             strncpy(file->srv_decrypt_opt, tok,
 372                     SIZEOF(file->srv_decrypt_opt) - 1);
 373             if ((tok = strtok_r(NULL, " ", &saveptr)) == NULL)
 374                 break;
 375         }
 376
 377         /* "clnt_decrypt_opt" is optional */
 378         if (BSTRNCMP(tok, "client_decrypt_option") == 0) {
 379             tok = strtok_r(NULL, " ", &saveptr);
 380             if (tok == NULL) {
 381                 strange_header(file, buffer, buflen,
 382                                 _("<client decrypt param>"), tok);
 383                 goto out;
 384             }
 385             strncpy(file->clnt_decrypt_opt, tok,
 386                     SIZEOF(file->clnt_decrypt_opt) - 1);
 387             if ((tok = strtok_r(NULL, " ", &saveptr)) == NULL)
 388                 break;
 389         }
 390       break;
 391
 392
 393     case F_TAPEEND:
 394         tok = strtok_r(NULL, " ", &saveptr);
 395         /* DATE is optional */
 396         if (tok != NULL) {
 397             if (strcmp(tok, "DATE") == 0) {
 398                 tok = strtok_r(NULL, " ", &saveptr);
 399                 if(tok == NULL)
 400                     file->datestamp[0] = '\0';
 401                 else
 402                     strncpy(file->datestamp, tok, SIZEOF(file->datestamp) - 1);
 403             } else {
 404                 strange_header(file, buffer, buflen, _("<DATE>"), tok);
 405            }
 406         } else {
 407             file->datestamp[0] = '\0';
 408         }
 409         break;
 410
 411     case F_NOOP:
 412         /* nothing follows */
 413         break;
 414
 415     default:
 416         strange_header(file, buffer, buflen,
 417                 _("TAPESTART|DUMPFILE|CONT_DUMPFILE|SPLIT_DUMPFILE|TAPEEND|NOOP"), tok);
 418         goto out;
 419     }
 420
 421     (void)strtok_r(buf, "\n", &saveptr); /* this is the first line */
 422     /* iterate through the rest of the lines */
 423     while ((line = strtok_r(NULL, "\n", &saveptr)) != NULL) {
 424 #define SC "CONT_FILENAME="
 425         if (strncmp(line, SC, SIZEOF(SC) - 1) == 0) {
 426             line += SIZEOF(SC) - 1;
 427             strncpy(file->cont_filename, line,
 428                     SIZEOF(file->cont_filename) - 1);
 429             continue;
 430         }
 431 #undef SC
 432
 433 #define SC "PARTIAL="
 434         if (strncmp(line, SC, SIZEOF(SC) - 1) == 0) {
 435             line += SIZEOF(SC) - 1;
 436             file->is_partial = !strcasecmp(line, "yes");
 437             continue;
 438         }
 439 #undef SC
 440 #define SC "APPLICATION="
 441         if (strncmp(line, SC, SIZEOF(SC) - 1) == 0) {
 442             line += SIZEOF(SC) - 1;
 443             strncpy(file->application, line,
 444                     SIZEOF(file->application) - 1);
 445             continue;
 446         }
 447 #undef SC
 448
 449 #define SC "ORIGSIZE="
 450         if (strncmp(line, SC, SIZEOF(SC) - 1) == 0) {
 451             line += SIZEOF(SC) - 1;
 452             file->orig_size = OFF_T_ATOI(line);
 453         }
 454 #undef SC
 455
 456 #define SC "DLE="
 457         if (strncmp(line, SC, SIZEOF(SC) - 1) == 0) {
 458             line += SIZEOF(SC) - 1;
 459             file->dle_str = parse_heredoc(line, &saveptr);
 460         }
 461 #undef SC
 462
 463 #define SC _("To restore, position tape at start of file and run:")
 464         if (strncmp(line, SC, SIZEOF(SC) - 1) == 0)
 465             continue;
 466 #undef SC
 467
 468 #define SC "\tdd if=<tape> "
 469         if (strncmp(line, SC, SIZEOF(SC) - 1) == 0) {
 470             char *cmd1, *cmd2, *cmd3=NULL;
 471
 472             /* skip over dd command */
 473             if ((cmd1 = strchr(line, '|')) == NULL) {
 474
 475                 strncpy(file->recover_cmd, "BUG",
 476                         SIZEOF(file->recover_cmd) - 1);
 477                 continue;
 478             }
 479             *cmd1++ = '\0';
 480
 481             /* block out first pipeline command */
 482             if ((cmd2 = strchr(cmd1, '|')) != NULL) {
 483               *cmd2++ = '\0';
 484               if ((cmd3 = strchr(cmd2, '|')) != NULL)
 485                 *cmd3++ = '\0';
 486             }
 487
 488             /* clean up some extra spaces in various fields */
 489             chomp(cmd1);
 490             chomp(cmd2);
 491             chomp(cmd3);
 492
 493             /* three cmds: decrypt    | uncompress | recover
 494              * two   cmds: uncompress | recover
 495              * XXX note that if there are two cmds, the first one
 496              * XXX could be either uncompress or decrypt. Since no
 497              * XXX code actually call uncompress_cmd/decrypt_cmd, it's ok
 498              * XXX for header information.
 499              * one   cmds: recover
 500              */
 501
 502             if ( cmd3 == NULL) {
 503               if (cmd2 == NULL) {
 504                 strncpy(file->recover_cmd, cmd1,
 505                         SIZEOF(file->recover_cmd) - 1);
 506               } else {
 507                 g_snprintf(file->uncompress_cmd,
 508                          SIZEOF(file->uncompress_cmd), "%s |", cmd1);
 509                 strncpy(file->recover_cmd, cmd2,
 510                         SIZEOF(file->recover_cmd) - 1);
 511               }
 512             } else {    /* cmd3 presents:  decrypt | uncompress | recover */
 513               g_snprintf(file->decrypt_cmd,
 514                        SIZEOF(file->decrypt_cmd), "%s |", cmd1);
 515               g_snprintf(file->uncompress_cmd,
 516                        SIZEOF(file->uncompress_cmd), "%s |", cmd2);
 517               strncpy(file->recover_cmd, cmd3,
 518                       SIZEOF(file->recover_cmd) - 1);
 519             }
 520             continue;
 521         }
 522 #undef SC
 523         /* XXX complain about weird lines? */
 524     }
 525
 526 out:
 527     amfree(buf);
 528     amfree(line1);
 529 }
 530
 531 void
 532 dump_dumpfile_t(
 533     const dumpfile_t *file)
 534 {
 535         g_debug(_("Contents of *(dumpfile_t *)%p:"), file);
 536         g_debug(_("    type             = %d (%s)"),
 537                         file->type, filetype2str(file->type));
 538         g_debug(_("    datestamp        = '%s'"), file->datestamp);
 539         g_debug(_("    dumplevel        = %d"), file->dumplevel);
 540         g_debug(_("    compressed       = %d"), file->compressed);
 541         g_debug(_("    encrypted        = %d"), file->encrypted);
 542         g_debug(_("    comp_suffix      = '%s'"), file->comp_suffix);
 543         g_debug(_("    encrypt_suffix   = '%s'"), file->encrypt_suffix);
 544         g_debug(_("    name             = '%s'"), file->name);
 545         g_debug(_("    disk             = '%s'"), file->disk);
 546         g_debug(_("    program          = '%s'"), file->program);
 547         g_debug(_("    application      = '%s'"), file->application);
 548         g_debug(_("    srvcompprog      = '%s'"), file->srvcompprog);
 549         g_debug(_("    clntcompprog     = '%s'"), file->clntcompprog);
 550         g_debug(_("    srv_encrypt      = '%s'"), file->srv_encrypt);
 551         g_debug(_("    clnt_encrypt     = '%s'"), file->clnt_encrypt);
 552         g_debug(_("    recover_cmd      = '%s'"), file->recover_cmd);
 553         g_debug(_("    uncompress_cmd   = '%s'"), file->uncompress_cmd);
 554         g_debug(_("    decrypt_cmd      = '%s'"), file->decrypt_cmd);
 555         g_debug(_("    srv_decrypt_opt  = '%s'"), file->srv_decrypt_opt);
 556         g_debug(_("    clnt_decrypt_opt = '%s'"), file->clnt_decrypt_opt);
 557         g_debug(_("    cont_filename    = '%s'"), file->cont_filename);
 558         if (file->dle_str)
 559             g_debug(_("    dle_str          = %s"), file->dle_str);
 560         else
 561             g_debug(_("    dle_str          = (null)"));
 562         g_debug(_("    is_partial       = %d"), file->is_partial);
 563         g_debug(_("    partnum          = %d"), file->partnum);
 564         g_debug(_("    totalparts       = %d"), file->totalparts);
 565         if (file->blocksize)
 566             g_debug(_("    blocksize        = %zu"), file->blocksize);
 567 }
 568
 569 static void
 570 validate_nonempty_str(
 571     const char *val,
 572     const char *name)
 573 {
 574     if (strlen(val) == 0) {
 575         error(_("Invalid %s '%s'\n"), name, val);
 576         /*NOTREACHED*/
 577     }
 578 }
 579
 580 static void
 581 validate_not_both(
 582     const char *val1, const char *val2,
 583     const char *name1, const char *name2)
 584 {
 585     if (*val1 && *val2) {
 586         error("cannot set both %s and %s\n", name1, name2);
 587     }
 588 }
 589
 590 static void
 591 validate_no_space(
 592     const char *val,
 593     const char *name)
 594 {
 595     if (strchr(val, ' ') != NULL) {
 596         error(_("%s cannot contain spaces\n"), name);
 597         /*NOTREACHED*/
 598     }
 599 }
 600
 601 static void
 602 validate_pipe_cmd(
 603         const char *cmd,
 604         const char *name)
 605 {
 606     if (strlen(cmd) && cmd[strlen(cmd)-1] != '|') {
 607         error("invalid %s (must end with '|'): '%s'\n", name, cmd);
 608     }
 609 }
 610
 611 static void
 612 validate_encrypt_suffix(
 613         int encrypted,
 614         const char *suff)
 615 {
 616     if (encrypted) {
 617         if (!suff[0] || (0 == strcmp(suff, "N"))) {
 618             error(_("Invalid encrypt_suffix '%s'\n"), suff);
 619         }
 620     } else {
 621         if (suff[0] && (0 != strcmp(suff, "N"))) {
 622             error(_("Invalid header: encrypt_suffix '%s' specified but not encrypted\n"), suff);
 623         }
 624     }
 625 }
 626
 627 static void
 628 validate_datestamp(
 629     const char *datestamp)
 630 {
 631         if (strcmp(datestamp, "X") == 0) {
 632             return;
 633         }
 634
 635         if ((strlen(datestamp) == 8) && match("^[0-9]{8}$", datestamp)) {
 636             return;
 637         }
 638         if ((strlen(datestamp) == 14) && match("^[0-9]{14}$", datestamp)) {
 639             return;
 640         }
 641         error(_("Invalid datestamp '%s'\n"), datestamp);
 642         /*NOTREACHED*/
 643 }
 644
 645 static void
 646 validate_parts(
 647     const int partnum,
 648     const int totalparts)
 649 {
 650         if (partnum < 1) {
 651             error(_("Invalid partnum (%d)\n"), partnum);
 652             /*NOTREACHED*/
 653         }
 654
 655         if (partnum > totalparts && totalparts >= 0) {
 656             error(_("Invalid partnum (%d) > totalparts (%d)\n"),
 657                         partnum, totalparts);
 658             /*NOTREACHED*/
 659         }
 660 }
 661
 662 char *
 663 build_header(const dumpfile_t * file, size_t *size, size_t max_size)
 664 {
 665     GString *rval, *split_data;
 666     char *qname;
 667     char *program;
 668     size_t min_size;
 669
 670     min_size = size? *size : max_size;
 671     g_debug(_("Building type %s header of %zu-%zu bytes with name='%s' disk='%s' dumplevel=%d and blocksize=%zu"),
 672             filetype2str(file->type), min_size, max_size,
 673             file->name, file->disk, file->dumplevel, file->blocksize);
 674
 675     rval = g_string_sized_new(min_size);
 676     split_data = g_string_sized_new(10);
 677
 678     switch (file->type) {
 679     case F_TAPESTART:
 680         validate_nonempty_str(file->name, "name");
 681         validate_datestamp(file->datestamp);
 682         g_string_printf(rval,
 683                         "AMANDA: TAPESTART DATE %s TAPE %s\n\014\n",
 684                         file->datestamp, file->name);
 685         break;
 686
 687     case F_SPLIT_DUMPFILE:
 688         validate_parts(file->partnum, file->totalparts);
 689         g_string_printf(split_data,
 690                         " part %d/%d ", file->partnum, file->totalparts);
 691         /* FALLTHROUGH */
 692
 693     case F_CONT_DUMPFILE:
 694     case F_DUMPFILE :
 695         validate_nonempty_str(file->name, "name");
 696         validate_nonempty_str(file->program, "program");
 697         validate_datestamp(file->datestamp);
 698         validate_encrypt_suffix(file->encrypted, file->encrypt_suffix);
 699         qname = quote_string(file->disk);
 700         program = stralloc(file->program);
 701         if (match("^.*[.][Ee][Xx][Ee]$", program)) {
 702                 /* Trim ".exe" from program name */
 703                 program[strlen(program) - strlen(".exe")] = '\0';
 704         }
 705         g_string_printf(rval,
 706                         "AMANDA: %s %s %s %s %s lev %d comp %s program %s",
 707                         filetype2str(file->type),
 708                         file->datestamp, file->name, qname,
 709                         split_data->str,
 710                         file->dumplevel,
 711                         file->compressed? file->comp_suffix : "N",
 712                         program);
 713         amfree(program);
 714         amfree(qname);
 715
 716         /* only output crypt if it's enabled */
 717         if (file->encrypted) {
 718             g_string_append_printf(rval, " crypt %s", file->encrypt_suffix);
 719         }
 720
 721         validate_not_both(file->srvcompprog, file->clntcompprog,
 722                             "srvcompprog", "clntcompprog");
 723         if (*file->srvcompprog) {
 724             validate_no_space(file->srvcompprog, "srvcompprog");
 725             g_string_append_printf(rval, " server_custom_compress %s",
 726                                    file->srvcompprog);
 727         } else if (*file->clntcompprog) {
 728             validate_no_space(file->clntcompprog, "clntcompprog");
 729             g_string_append_printf(rval, " client_custom_compress %s",
 730                                    file->clntcompprog);
 731         }
 732
 733         validate_not_both(file->srv_encrypt, file->clnt_encrypt,
 734                             "srv_encrypt", "clnt_encrypt");
 735         if (*file->srv_encrypt) {
 736             validate_no_space(file->srv_encrypt, "srv_encrypt");
 737             g_string_append_printf(rval, " server_encrypt %s",
 738                                    file->srv_encrypt);
 739         } else if (*file->clnt_encrypt) {
 740             validate_no_space(file->clnt_encrypt, "clnt_encrypt");
 741             g_string_append_printf(rval, " client_encrypt %s",
 742                                    file->clnt_encrypt);
 743         }
 744
 745         validate_not_both(file->srv_decrypt_opt, file->clnt_decrypt_opt,
 746                             "srv_decrypt_opt", "clnt_decrypt_opt");
 747         if (*file->srv_decrypt_opt) {
 748             validate_no_space(file->srv_decrypt_opt, "srv_decrypt_opt");
 749             g_string_append_printf(rval, " server_decrypt_option %s",
 750                                    file->srv_decrypt_opt);
 751         } else if (*file->clnt_decrypt_opt) {
 752             g_string_append_printf(rval, " client_decrypt_option %s",
 753                                    file->clnt_decrypt_opt);
 754         }
 755
 756         g_string_append_printf(rval, "\n");
 757
 758         if (file->cont_filename[0] != '\0') {
 759             g_string_append_printf(rval, "CONT_FILENAME=%s\n",
 760                                    file->cont_filename);
 761         }
 762         if (file->application[0] != '\0') {
 763             g_string_append_printf(rval, "APPLICATION=%s\n", file->application);
 764         }
 765         if (file->is_partial != 0) {
 766             g_string_append_printf(rval, "PARTIAL=YES\n");
 767         }
 768         if (file->orig_size > 0) {
 769             g_string_append_printf(rval, "ORIGSIZE=%jd\n",
 770                                          (intmax_t)file->orig_size);
 771         }
 772         if (file->dle_str && strlen(file->dle_str) < max_size-2048) {
 773             char *heredoc = quote_heredoc(file->dle_str, "ENDDLE");
 774             g_string_append_printf(rval, "DLE=%s\n", heredoc);
 775             amfree(heredoc);
 776         }
 777
 778         g_string_append_printf(rval,
 779             _("To restore, position tape at start of file and run:\n"));
 780
 781         g_string_append_printf(rval, "\tdd if=<tape> ");
 782         if (file->blocksize)
 783             g_string_append_printf(rval, "bs=%zuk ",
 784                                    file->blocksize / 1024);
 785         g_string_append_printf(rval, "skip=1 | ");
 786         if (*file->recover_cmd) {
 787             if (*file->decrypt_cmd) {
 788                 validate_pipe_cmd(file->decrypt_cmd, "decrypt_cmd");
 789                 g_string_append_printf(rval, "%s ", file->decrypt_cmd);
 790             }
 791             if (*file->uncompress_cmd) {
 792                 validate_pipe_cmd(file->uncompress_cmd, "uncompress_cmd");
 793                 g_string_append_printf(rval, "%s ", file->uncompress_cmd);
 794             }
 795             g_string_append_printf(rval, "%s ", file->recover_cmd);
 796         } else {
 797             if (*file->uncompress_cmd || *file->decrypt_cmd)
 798                 error("cannot specify uncompress_cmd or decrypt_cmd without recover_cmd\n");
 799         }
 800         /* \014 == ^L == form feed */
 801         g_string_append_printf(rval, "\n\014\n");
 802         break;
 803
 804     case F_TAPEEND:
 805         validate_datestamp(file->datestamp);
 806         g_string_printf(rval, "AMANDA: TAPEEND DATE %s\n\014\n",
 807                         file->datestamp);
 808         break;
 809
 810     case F_NOOP:
 811         g_string_printf(rval, "AMANDA: NOOP\n\014\n");
 812         break;
 813
 814     case F_UNKNOWN:
 815     case F_EMPTY:
 816     case F_WEIRD:
 817     default:
 818         error(_("Invalid header type: %d (%s)"),
 819                 file->type, filetype2str(file->type));
 820         /*NOTREACHED*/
 821     }
 822
 823     g_string_free(split_data, TRUE);
 824
 825     /* is it too big? */
 826     if (rval->len > max_size) {
 827         g_debug("header is larger than %zu bytes -- cannot create", max_size);
 828         g_string_free(rval, TRUE);
 829         return NULL;
 830     }
 831
 832     /* Clear extra bytes. */
 833     if (rval->len < min_size) {
 834         bzero(rval->str + rval->len, rval->allocated_len - rval->len);
 835     }
 836     if (size) {
 837         *size = MAX(min_size, (size_t)rval->len);
 838     }
 839     return g_string_free(rval, FALSE);
 840 }
 841
 842 void
 843 print_header(
 844     FILE *              outf,
 845     const dumpfile_t *  file)
 846 {
 847     char *summ = summarize_header(file);
 848     g_fprintf(outf, "%s\n", summ);
 849     g_free(summ);
 850 }
 851
 852 /*
 853  * Prints the contents of the file structure.
 854  */
 855 char *
 856 summarize_header(
 857     const dumpfile_t *  file)
 858 {
 859     char *qdisk;
 860     GString *summ;
 861
 862     switch(file->type) {
 863     case F_EMPTY:
 864         return g_strdup(_("EMPTY file"));
 865
 866     case F_UNKNOWN:
 867         return g_strdup(_("UNKNOWN file"));
 868
 869     default:
 870     case F_WEIRD:
 871         return g_strdup(_("WEIRD file"));
 872
 873     case F_TAPESTART:
 874         return g_strdup_printf(_("start of tape: date %s label %s"),
 875                file->datestamp, file->name);
 876
 877     case F_NOOP:
 878         return g_strdup(_("NOOP file"));
 879
 880     case F_DUMPFILE:
 881     case F_CONT_DUMPFILE:
 882         qdisk = quote_string(file->disk);
 883         summ = g_string_new("");
 884         g_string_printf(summ, "%s: date %s host %s disk %s lev %d comp %s",
 885             filetype2str(file->type), file->datestamp, file->name,
 886             qdisk, file->dumplevel,
 887             file->compressed? file->comp_suffix : "N");
 888         amfree(qdisk);
 889         goto add_suffixes;
 890
 891     case F_SPLIT_DUMPFILE: {
 892         char totalparts[NUM_STR_SIZE*2];
 893         if(file->totalparts > 0)
 894             g_snprintf(totalparts, SIZEOF(totalparts), "%d", file->totalparts);
 895         else
 896             g_snprintf(totalparts, SIZEOF(totalparts), "UNKNOWN");
 897         qdisk = quote_string(file->disk);
 898         summ = g_string_new("");
 899         g_string_printf(summ, "split dumpfile: date %s host %s disk %s"
 900                       " part %d/%s lev %d comp %s",
 901                       file->datestamp, file->name, qdisk, file->partnum,
 902                       totalparts, file->dumplevel,
 903                       file->compressed? file->comp_suffix : "N");
 904         amfree(qdisk);
 905         goto add_suffixes;
 906     }
 907
 908     add_suffixes:
 909         if (*file->program)
 910             g_string_append_printf(summ, " program %s", file->program);
 911         if (strcmp(file->encrypt_suffix, "enc") == 0)
 912             g_string_append_printf(summ, " crypt %s", file->encrypt_suffix);
 913         if (*file->srvcompprog)
 914             g_string_append_printf(summ, " server_custom_compress %s", file->srvcompprog);
 915         if (*file->clntcompprog)
 916             g_string_append_printf(summ, " client_custom_compress %s", file->clntcompprog);
 917         if (*file->srv_encrypt)
 918             g_string_append_printf(summ, " server_encrypt %s", file->srv_encrypt);
 919         if (*file->clnt_encrypt)
 920             g_string_append_printf(summ, " client_encrypt %s", file->clnt_encrypt);
 921         if (*file->srv_decrypt_opt)
 922             g_string_append_printf(summ, " server_decrypt_option %s", file->srv_decrypt_opt);
 923         if (*file->clnt_decrypt_opt)
 924             g_string_append_printf(summ, " client_decrypt_option %s", file->clnt_decrypt_opt);
 925         return g_string_free(summ, FALSE);
 926
 927     case F_TAPEEND:
 928         return g_strdup_printf("end of tape: date %s", file->datestamp);
 929         break;
 930     }
 931 }
 932
 933 int
 934 known_compress_type(
 935     const dumpfile_t *  file)
 936 {
 937     if(strcmp(file->comp_suffix, ".Z") == 0)
 938         return 1;
 939 #ifdef HAVE_GZIP
 940     if(strcmp(file->comp_suffix, ".gz") == 0)
 941         return 1;
 942 #endif
 943     if(strcmp(file->comp_suffix, "cust") == 0)
 944         return 1;
 945     return 0;
 946 }
 947
 948 static const struct {
 949     filetype_t type;
 950     const char *str;
 951 } filetypetab[] = {
 952     { F_UNKNOWN, "UNKNOWN" },
 953     { F_WEIRD, "WEIRD" },
 954     { F_TAPESTART, "TAPESTART" },
 955     { F_TAPEEND,  "TAPEEND" },
 956     { F_DUMPFILE, "FILE" },
 957     { F_CONT_DUMPFILE, "CONT_FILE" },
 958     { F_SPLIT_DUMPFILE, "SPLIT_FILE" },
 959     { F_NOOP, "NOOP" }
 960 };
 961 #define NFILETYPES      (size_t)(sizeof(filetypetab) / sizeof(filetypetab[0]))
 962
 963 static const char *
 964 filetype2str(
 965     filetype_t  type)
 966 {
 967     int i;
 968
 969     for (i = 0; i < (int)NFILETYPES; i++)
 970         if (filetypetab[i].type == type)
 971             return (filetypetab[i].str);
 972     return ("UNKNOWN");
 973 }
 974
 975 static filetype_t
 976 str2filetype(
 977     const char *str)
 978 {
 979     int i;
 980
 981     for (i = 0; i < (int)NFILETYPES; i++)
 982         if (strcmp(filetypetab[i].str, str) == 0)
 983             return (filetypetab[i].type);
 984     return (F_UNKNOWN);
 985 }
 986
 987 gboolean headers_are_equal(dumpfile_t * a, dumpfile_t * b) {
 988     if (a == NULL && b == NULL)
 989         return TRUE;
 990
 991     if (a == NULL || b == NULL)
 992         return FALSE;
 993
 994     if (a->type != b->type) return FALSE;
 995     if (strcmp(a->datestamp, b->datestamp)) return FALSE;
 996     if (a->dumplevel != b->dumplevel) return FALSE;
 997     if (a->compressed != b->compressed) return FALSE;
 998     if (a->encrypted != b->encrypted) return FALSE;
 999     if (strcmp(a->comp_suffix, b->comp_suffix)) return FALSE;
1000     if (strcmp(a->encrypt_suffix, b->encrypt_suffix)) return FALSE;
1001     if (strcmp(a->name, b->name)) return FALSE;
1002     if (strcmp(a->disk, b->disk)) return FALSE;
1003     if (strcmp(a->program, b->program)) return FALSE;
1004     if (strcmp(a->application, b->application)) return FALSE;
1005     if (strcmp(a->srvcompprog, b->srvcompprog)) return FALSE;
1006     if (strcmp(a->clntcompprog, b->clntcompprog)) return FALSE;
1007     if (strcmp(a->srv_encrypt, b->srv_encrypt)) return FALSE;
1008     if (strcmp(a->clnt_encrypt, b->clnt_encrypt)) return FALSE;
1009     if (strcmp(a->recover_cmd, b->recover_cmd)) return FALSE;
1010     if (strcmp(a->uncompress_cmd, b->uncompress_cmd)) return FALSE;
1011     if (strcmp(a->decrypt_cmd, b->decrypt_cmd)) return FALSE;
1012     if (strcmp(a->srv_decrypt_opt, b->srv_decrypt_opt)) return FALSE;
1013     if (strcmp(a->clnt_decrypt_opt, b->clnt_decrypt_opt)) return FALSE;
1014     if (strcmp(a->cont_filename, b->cont_filename)) return FALSE;
1015     if (a->dle_str != b->dle_str && a->dle_str && b->dle_str
1016         && strcmp(a->dle_str, b->dle_str)) return FALSE;
1017     if (a->is_partial != b->is_partial) return FALSE;
1018     if (a->partnum != b->partnum) return FALSE;
1019     if (a->totalparts != b->totalparts) return FALSE;
1020     if (a->blocksize != b->blocksize) return FALSE;
1021
1022     return TRUE; /* ok, they're the same */
1023 }
1024
1025 dumpfile_t * dumpfile_copy(dumpfile_t* source) {
1026     dumpfile_t* rval = malloc(sizeof(dumpfile_t));
1027     memcpy(rval, source, sizeof(dumpfile_t));
1028     if (rval->dle_str) rval->dle_str = stralloc(rval->dle_str);
1029     return rval;
1030 }
1031
1032 void
1033 dumpfile_copy_in_place(
1034     dumpfile_t *dest,
1035     dumpfile_t* source)
1036 {
1037     memcpy(dest, source, sizeof(dumpfile_t));
1038     if (dest->dle_str) dest->dle_str = stralloc(dest->dle_str);
1039 }
1040
1041 void dumpfile_free_data(dumpfile_t* info) {
1042     if (info) {
1043         amfree(info->dle_str);
1044     }
1045 }
1046
1047 void dumpfile_free(dumpfile_t* info) {
1048     dumpfile_free_data(info);
1049     amfree(info);
1050 }
1051
1052 static char *quote_heredoc(
1053     char  *text,
1054     char  *delimiter_prefix)
1055 {
1056     char *delimiter = stralloc(delimiter_prefix);
1057     int delimiter_n = 0;
1058     int delimiter_len = strlen(delimiter);
1059     char *quoted;
1060
1061     /* keep picking delimiters until we find one that's not a line in TEXT */
1062     while (1) {
1063         char *line = text;
1064         char *c = text;
1065         gboolean found_delimiter = FALSE;
1066
1067         while (1) {
1068             if (*c == '\n' || *c == '\0') {
1069                 int linelen = c - line;
1070                 if (linelen == delimiter_len && 0 == strncmp(line, delimiter, linelen)) {
1071                     found_delimiter = TRUE;
1072                     break;
1073                 }
1074                 line = c+1;
1075             }
1076             if (!*c) break;
1077             c++;
1078         }
1079
1080         if (!found_delimiter)
1081             break;
1082
1083         delimiter = newvstrallocf(delimiter, "%s%d", delimiter_prefix, ++delimiter_n);
1084         delimiter_len = strlen(delimiter);
1085     }
1086
1087     /* we have a delimiter .. now use it */
1088     quoted = vstrallocf("<<%s\n%s\n%s", delimiter, text, delimiter);
1089     amfree(delimiter);
1090     return quoted;
1091 }
1092
1093 static char *parse_heredoc(
1094     char  *line,
1095     char **saveptr)
1096 {
1097     char *result = NULL;
1098
1099     if (strncmp(line, "<<", 2) == 0) {
1100         char *keyword = line+2;
1101         char *new_line;
1102
1103         while((new_line = strtok_r(NULL, "\n", saveptr)) != NULL &&
1104               strcmp(new_line, keyword) != 0) {
1105             result = vstrextend(&result, new_line, "\n", NULL);
1106         }
1107         /* make sure we have something */
1108         if (!result)
1109             result = g_strdup("");
1110         /* remove latest '\n' */
1111         else if (strlen(result) > 0)
1112             result[strlen(result)-1] = '\0';
1113     } else {
1114         result = stralloc(line);
1115     }
1116     return result;
1117 }