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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2002-2010 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 Database File tree for Restore
  31  *      command. This file interacts with the user implementing the
  32  *      UA tree commands.
  33  *
  34  *     Kern Sibbald, July MMII
  35  *
  36  */
  37
  38 #include "bacula.h"
  39 #include "dird.h"
  40 #ifdef HAVE_FNMATCH
  41 #include <fnmatch.h>
  42 #else
  43 #include "lib/fnmatch.h"
  44 #endif
  45 #include "findlib/find.h"
  46
  47
  48 /* Forward referenced commands */
  49
  50 static int markcmd(UAContext *ua, TREE_CTX *tree);
  51 static int markdircmd(UAContext *ua, TREE_CTX *tree);
  52 static int countcmd(UAContext *ua, TREE_CTX *tree);
  53 static int findcmd(UAContext *ua, TREE_CTX *tree);
  54 static int lscmd(UAContext *ua, TREE_CTX *tree);
  55 static int lsmarkcmd(UAContext *ua, TREE_CTX *tree);
  56 static int dircmd(UAContext *ua, TREE_CTX *tree);
  57 static int dot_dircmd(UAContext *ua, TREE_CTX *tree);
  58 static int estimatecmd(UAContext *ua, TREE_CTX *tree);
  59 static int helpcmd(UAContext *ua, TREE_CTX *tree);
  60 static int cdcmd(UAContext *ua, TREE_CTX *tree);
  61 static int pwdcmd(UAContext *ua, TREE_CTX *tree);
  62 static int dot_pwdcmd(UAContext *ua, TREE_CTX *tree);
  63 static int unmarkcmd(UAContext *ua, TREE_CTX *tree);
  64 static int unmarkdircmd(UAContext *ua, TREE_CTX *tree);
  65 static int quitcmd(UAContext *ua, TREE_CTX *tree);
  66 static int donecmd(UAContext *ua, TREE_CTX *tree);
  67 static int dot_lsdircmd(UAContext *ua, TREE_CTX *tree);
  68 static int dot_lscmd(UAContext *ua, TREE_CTX *tree);
  69 static int dot_helpcmd(UAContext *ua, TREE_CTX *tree);
  70 static int dot_lsmarkcmd(UAContext *ua, TREE_CTX *tree);
  71
  72 struct cmdstruct { const char *key; int (*func)(UAContext *ua, TREE_CTX *tree); const char *help; };
  73 static struct cmdstruct commands[] = {
  74  { NT_("add"),        markcmd,      _("add dir/file to be restored recursively, wildcards allowed")},
  75  { NT_("cd"),         cdcmd,        _("change current directory")},
  76  { NT_("count"),      countcmd,     _("count marked files in and below the cd")},
  77  { NT_("delete"),     unmarkcmd,    _("delete dir/file to be restored recursively in dir")},
  78  { NT_("dir"),        dircmd,       _("long list current directory, wildcards allowed")},
  79  { NT_(".dir"),       dot_dircmd,   _("long list current directory, wildcards allowed")},
  80  { NT_("done"),       donecmd,      _("leave file selection mode")},
  81  { NT_("estimate"),   estimatecmd,  _("estimate restore size")},
  82  { NT_("exit"),       donecmd,      _("same as done command")},
  83  { NT_("find"),       findcmd,      _("find files, wildcards allowed")},
  84  { NT_("help"),       helpcmd,      _("print help")},
  85  { NT_("ls"),         lscmd,        _("list current directory, wildcards allowed")},
  86  { NT_(".ls"),        dot_lscmd,    _("list current directory, wildcards allowed")},
  87  { NT_(".lsdir"),     dot_lsdircmd, _("list subdir in current directory, wildcards allowed")},
  88  { NT_("lsmark"),     lsmarkcmd,    _("list the marked files in and below the cd")},
  89  { NT_(".lsmark"),    dot_lsmarkcmd,_("list the marked files in")},
  90  { NT_("mark"),       markcmd,      _("mark dir/file to be restored recursively, wildcards allowed")},
  91  { NT_("markdir"),    markdircmd,   _("mark directory name to be restored (no files)")},
  92  { NT_("pwd"),        pwdcmd,       _("print current working directory")},
  93  { NT_(".pwd"),       dot_pwdcmd,   _("print current working directory")},
  94  { NT_("unmark"),     unmarkcmd,    _("unmark dir/file to be restored recursively in dir")},
  95  { NT_("unmarkdir"),  unmarkdircmd, _("unmark directory name only no recursion")},
  96  { NT_("quit"),       quitcmd,      _("quit and do not do restore")},
  97  { NT_(".help"),      dot_helpcmd,  _("print help")},
  98  { NT_("?"),          helpcmd,      _("print help")},
  99              };
 100 #define comsize ((int)(sizeof(commands)/sizeof(struct cmdstruct)))
 101
 102 /*
 103  * Enter a prompt mode where the user can select/deselect
 104  *  files to be restored. This is sort of like a mini-shell
 105  *  that allows "cd", "pwd", "add", "rm", ...
 106  */
 107 bool user_select_files_from_tree(TREE_CTX *tree)
 108 {
 109    char cwd[2000];
 110    bool stat;
 111    /* Get a new context so we don't destroy restore command args */
 112    UAContext *ua = new_ua_context(tree->ua->jcr);
 113    ua->UA_sock = tree->ua->UA_sock;   /* patch in UA socket */
 114    ua->api = tree->ua->api;           /* keep API flag too */
 115    BSOCK *user = ua->UA_sock;
 116
 117    ua->send_msg(_(
 118       "\nYou are now entering file selection mode where you add (mark) and\n"
 119       "remove (unmark) files to be restored. No files are initially added, unless\n"
 120       "you used the \"all\" keyword on the command line.\n"
 121       "Enter \"done\" to leave this mode.\n\n"));
 122    if (ua->api) user->signal(BNET_START_RTREE);
 123    /*
 124     * Enter interactive command handler allowing selection
 125     *  of individual files.
 126     */
 127    tree->node = (TREE_NODE *)tree->root;
 128    tree_getpath(tree->node, cwd, sizeof(cwd));
 129    ua->send_msg(_("cwd is: %s\n"), cwd);
 130    for ( ;; ) {
 131       int found, len, i;
 132       if (!get_cmd(ua, "$ ", true)) {
 133          break;
 134       }
 135       if (ua->api) user->signal(BNET_CMD_BEGIN);
 136       parse_args_only(ua->cmd, &ua->args, &ua->argc, ua->argk, ua->argv, MAX_CMD_ARGS);
 137       if (ua->argc == 0) {
 138          ua->warning_msg(_("Invalid command \"%s\". Enter \"done\" to exit.\n"), ua->cmd);
 139          if (ua->api) user->signal(BNET_CMD_FAILED);
 140          continue;
 141       }
 142
 143       len = strlen(ua->argk[0]);
 144       found = 0;
 145       stat = false;
 146       for (i=0; i<comsize; i++)       /* search for command */
 147          if (strncasecmp(ua->argk[0],  commands[i].key, len) == 0) {
 148             stat = (*commands[i].func)(ua, tree);   /* go execute command */
 149             found = 1;
 150             break;
 151          }
 152       if (!found) {
 153          if (*ua->argk[0] == '.') {
 154             /* Some unknow dot command -- probably .messages, ignore it */
 155             continue;
 156          }
 157          ua->warning_msg(_("Invalid command \"%s\". Enter \"done\" to exit.\n"), ua->cmd);
 158          if (ua->api) user->signal(BNET_CMD_FAILED);
 159          continue;
 160       }
 161       if (ua->api) user->signal(BNET_CMD_OK);
 162       if (!stat) {
 163          break;
 164       }
 165    }
 166    if (ua->api) user->signal(BNET_END_RTREE);
 167    ua->UA_sock = NULL;                /* don't release restore socket */
 168    stat = !ua->quit;
 169    ua->quit = false;
 170    free_ua_context(ua);               /* get rid of temp UA context */
 171    return stat;
 172 }
 173
 174
 175 /*
 176  * This callback routine is responsible for inserting the
 177  *  items it gets into the directory tree. For each JobId selected
 178  *  this routine is called once for each file. We do not allow
 179  *  duplicate filenames, but instead keep the info from the most
 180  *  recent file entered (i.e. the JobIds are assumed to be sorted)
 181  *
 182  *   See uar_sel_files in sql_cmds.c for query that calls us.
 183  *      row[0]=Path, row[1]=Filename, row[2]=FileIndex
 184  *      row[3]=JobId row[4]=LStat row[5]=MarkId
 185  */
 186 int insert_tree_handler(void *ctx, int num_fields, char **row)
 187 {
 188    struct stat statp;
 189    TREE_CTX *tree = (TREE_CTX *)ctx;
 190    TREE_NODE *node;
 191    int type;
 192    bool hard_link, ok;
 193    int FileIndex;
 194    int32_t delta_seq;
 195    JobId_t JobId;
 196
 197    Dmsg4(100, "Path=%s%s FI=%s JobId=%s\n", row[0], row[1],
 198          row[2], row[3]);
 199    if (*row[1] == 0) {                 /* no filename => directory */
 200       if (!IsPathSeparator(*row[0])) { /* Must be Win32 directory */
 201          type = TN_DIR_NLS;
 202       } else {
 203          type = TN_DIR;
 204       }
 205    } else {
 206       type = TN_FILE;
 207    }
 208    hard_link = (decode_LinkFI(row[4], &statp) != 0);
 209    node = insert_tree_node(row[0], row[1], type, tree->root, NULL);
 210    JobId = str_to_int64(row[3]);
 211    FileIndex = str_to_int64(row[2]);
 212    delta_seq = str_to_int64(row[5]);
 213    Dmsg5(100, "node=0x%p JobId=%s FileIndex=%s Delta=%s node.delta=%d\n",
 214          node, row[3], row[2], row[5], node->delta_seq);
 215
 216    /* TODO: check with hardlinks */
 217    if (delta_seq > 0) {
 218       if (delta_seq == (node->delta_seq + 1)) {
 219          tree_add_delta_part(tree->root, node, node->JobId, node->FileIndex);
 220
 221       } else {
 222          /* File looks to be deleted */
 223          if (node->delta_seq == -1) { /* just created */
 224             tree_remove_node(tree->root, node);
 225
 226          } else {
 227             Dmsg3(0, "Something is wrong with Delta, skipt it "
 228                   "fname=%s d1=%d d2=%d\n",
 229                   row[1], node->delta_seq, delta_seq);
 230          }
 231          return 0;
 232       }
 233    }
 234    /*
 235     * - The first time we see a file (node->inserted==true), we accept it.
 236     * - In the same JobId, we accept only the first copy of a
 237     *   hard linked file (the others are simply pointers).
 238     * - In the same JobId, we accept the last copy of any other
 239     *   file -- in particular directories.
 240     *
 241     * All the code to set ok could be condensed to a single
 242     *  line, but it would be even harder to read.
 243     */
 244    ok = true;
 245    if (!node->inserted && JobId == node->JobId) {
 246       if ((hard_link && FileIndex > node->FileIndex) ||
 247           (!hard_link && FileIndex < node->FileIndex)) {
 248          ok = false;
 249       }
 250    }
 251    if (ok) {
 252       node->hard_link = hard_link;
 253       node->FileIndex = FileIndex;
 254       node->JobId = JobId;
 255       node->type = type;
 256       node->soft_link = S_ISLNK(statp.st_mode) != 0;
 257       node->delta_seq = delta_seq;
 258
 259       if (tree->all) {
 260          node->extract = true;          /* extract all by default */
 261          if (type == TN_DIR || type == TN_DIR_NLS) {
 262             node->extract_dir = true;   /* if dir, extract it */
 263          }
 264       }
 265    }
 266    if (node->inserted) {
 267       tree->FileCount++;
 268       if (tree->DeltaCount > 0 && (tree->FileCount-tree->LastCount) > tree->DeltaCount) {
 269          tree->ua->send_msg("+");
 270          tree->LastCount = tree->FileCount;
 271       }
 272    }
 273    tree->cnt++;
 274    return 0;
 275 }
 276
 277
 278 /*
 279  * Set extract to value passed. We recursively walk
 280  *  down the tree setting all children if the
 281  *  node is a directory.
 282  */
 283 static int set_extract(UAContext *ua, TREE_NODE *node, TREE_CTX *tree, bool extract)
 284 {
 285    TREE_NODE *n;
 286    FILE_DBR fdbr;
 287    struct stat statp;
 288    int count = 0;
 289
 290    node->extract = extract;
 291    if (node->type == TN_DIR || node->type == TN_DIR_NLS) {
 292       node->extract_dir = extract;    /* set/clear dir too */
 293    }
 294    if (node->type != TN_NEWDIR) {
 295       count++;
 296    }
 297    /* For a non-file (i.e. directory), we see all the children */
 298    if (node->type != TN_FILE || (node->soft_link && tree_node_has_child(node))) {
 299       /* Recursive set children within directory */
 300       foreach_child(n, node) {
 301          count += set_extract(ua, n, tree, extract);
 302       }
 303       /*
 304        * Walk up tree marking any unextracted parent to be
 305        * extracted.
 306        */
 307       if (extract) {
 308          while (node->parent && !node->parent->extract_dir) {
 309             node = node->parent;
 310             node->extract_dir = true;
 311          }
 312       }
 313    } else if (extract) {
 314       char cwd[2000];
 315       /*
 316        * Ordinary file, we get the full path, look up the
 317        * attributes, decode them, and if we are hard linked to
 318        * a file that was saved, we must load that file too.
 319        */
 320       tree_getpath(node, cwd, sizeof(cwd));
 321       fdbr.FileId = 0;
 322       fdbr.JobId = node->JobId;
 323       if (node->hard_link && db_get_file_attributes_record(ua->jcr, ua->db, cwd, NULL, &fdbr)) {
 324          int32_t LinkFI;
 325          decode_stat(fdbr.LStat, &statp, &LinkFI); /* decode stat pkt */
 326          /*
 327           * If we point to a hard linked file, traverse the tree to
 328           * find that file, and mark it to be restored as well. It
 329           * must have the Link we just obtained and the same JobId.
 330           */
 331          if (LinkFI) {
 332             for (n=first_tree_node(tree->root); n; n=next_tree_node(n)) {
 333                if (n->FileIndex == LinkFI && n->JobId == node->JobId) {
 334                   n->extract = true;
 335                   if (n->type == TN_DIR || n->type == TN_DIR_NLS) {
 336                      n->extract_dir = true;
 337                   }
 338                   break;
 339                }
 340             }
 341          }
 342       }
 343    }
 344    return count;
 345 }
 346
 347 static void strip_trailing_slash(char *arg)
 348 {
 349    int len = strlen(arg);
 350    if (len == 0) {
 351       return;
 352    }
 353    len--;
 354    if (arg[len] == '/') {       /* strip any trailing slash */
 355       arg[len] = 0;
 356    }
 357 }
 358
 359 /*
 360  * Recursively mark the current directory to be restored as
 361  *  well as all directories and files below it.
 362  */
 363 static int markcmd(UAContext *ua, TREE_CTX *tree)
 364 {
 365    TREE_NODE *node;
 366    int count = 0;
 367    char ec1[50];
 368
 369    if (ua->argc < 2 || !tree_node_has_child(tree->node)) {
 370       ua->send_msg(_("No files marked.\n"));
 371       return 1;
 372    }
 373    for (int i=1; i < ua->argc; i++) {
 374       strip_trailing_slash(ua->argk[i]);
 375       foreach_child(node, tree->node) {
 376          if (fnmatch(ua->argk[i], node->fname, 0) == 0) {
 377             count += set_extract(ua, node, tree, true);
 378          }
 379       }
 380    }
 381    if (count == 0) {
 382       ua->send_msg(_("No files marked.\n"));
 383    } else if (count == 1) {
 384       ua->send_msg(_("1 file marked.\n"));
 385    } else {
 386       ua->send_msg(_("%s files marked.\n"),
 387                edit_uint64_with_commas(count, ec1));
 388    }
 389    return 1;
 390 }
 391
 392 static int markdircmd(UAContext *ua, TREE_CTX *tree)
 393 {
 394    TREE_NODE *node;
 395    int count = 0;
 396    char ec1[50];
 397
 398    if (ua->argc < 2 || !tree_node_has_child(tree->node)) {
 399       ua->send_msg(_("No files marked.\n"));
 400       return 1;
 401    }
 402    for (int i=1; i < ua->argc; i++) {
 403       strip_trailing_slash(ua->argk[i]);
 404       foreach_child(node, tree->node) {
 405          if (fnmatch(ua->argk[i], node->fname, 0) == 0) {
 406             if (node->type == TN_DIR || node->type == TN_DIR_NLS) {
 407                node->extract_dir = true;
 408                count++;
 409             }
 410          }
 411       }
 412    }
 413    if (count == 0) {
 414       ua->send_msg(_("No directories marked.\n"));
 415    } else if (count == 1) {
 416       ua->send_msg(_("1 directory marked.\n"));
 417    } else {
 418       ua->send_msg(_("%s directories marked.\n"),
 419                edit_uint64_with_commas(count, ec1));
 420    }
 421    return 1;
 422 }
 423
 424
 425 static int countcmd(UAContext *ua, TREE_CTX *tree)
 426 {
 427    int total, num_extract;
 428    char ec1[50], ec2[50];
 429
 430    total = num_extract = 0;
 431    for (TREE_NODE *node=first_tree_node(tree->root); node; node=next_tree_node(node)) {
 432       if (node->type != TN_NEWDIR) {
 433          total++;
 434          if (node->extract || node->extract_dir) {
 435             num_extract++;
 436          }
 437       }
 438    }
 439    ua->send_msg(_("%s total files/dirs. %s marked to be restored.\n"),
 440             edit_uint64_with_commas(total, ec1),
 441             edit_uint64_with_commas(num_extract, ec2));
 442    return 1;
 443 }
 444
 445 static int findcmd(UAContext *ua, TREE_CTX *tree)
 446 {
 447    char cwd[2000];
 448
 449    if (ua->argc == 1) {
 450       ua->send_msg(_("No file specification given.\n"));
 451       return 1;      /* make it non-fatal */
 452    }
 453
 454    for (int i=1; i < ua->argc; i++) {
 455       for (TREE_NODE *node=first_tree_node(tree->root); node; node=next_tree_node(node)) {
 456          if (fnmatch(ua->argk[i], node->fname, 0) == 0) {
 457             const char *tag;
 458             tree_getpath(node, cwd, sizeof(cwd));
 459             if (node->extract) {
 460                tag = "*";
 461             } else if (node->extract_dir) {
 462                tag = "+";
 463             } else {
 464                tag = "";
 465             }
 466             ua->send_msg("%s%s\n", tag, cwd);
 467          }
 468       }
 469    }
 470    return 1;
 471 }
 472
 473 static int dot_lsdircmd(UAContext *ua, TREE_CTX *tree)
 474 {
 475    TREE_NODE *node;
 476
 477    if (!tree_node_has_child(tree->node)) {
 478       return 1;
 479    }
 480
 481    foreach_child(node, tree->node) {
 482       if (ua->argc == 1 || fnmatch(ua->argk[1], node->fname, 0) == 0) {
 483          if (tree_node_has_child(node)) {
 484             ua->send_msg("%s/\n", node->fname);
 485          }
 486       }
 487    }
 488
 489    return 1;
 490 }
 491
 492 static int dot_helpcmd(UAContext *ua, TREE_CTX *tree)
 493 {
 494    for (int i=0; i<comsize; i++) {
 495       /* List only non-dot commands */
 496       if (commands[i].key[0] != '.') {
 497          ua->send_msg("%s\n", commands[i].key);
 498       }
 499    }
 500    return 1;
 501 }
 502
 503 static int dot_lscmd(UAContext *ua, TREE_CTX *tree)
 504 {
 505    TREE_NODE *node;
 506
 507    if (!tree_node_has_child(tree->node)) {
 508       return 1;
 509    }
 510
 511    foreach_child(node, tree->node) {
 512       if (ua->argc == 1 || fnmatch(ua->argk[1], node->fname, 0) == 0) {
 513          ua->send_msg("%s%s\n", node->fname, tree_node_has_child(node)?"/":"");
 514       }
 515    }
 516
 517    return 1;
 518 }
 519
 520 static int lscmd(UAContext *ua, TREE_CTX *tree)
 521 {
 522    TREE_NODE *node;
 523
 524    if (!tree_node_has_child(tree->node)) {
 525       return 1;
 526    }
 527    foreach_child(node, tree->node) {
 528       if (ua->argc == 1 || fnmatch(ua->argk[1], node->fname, 0) == 0) {
 529          const char *tag;
 530          if (node->extract) {
 531             tag = "*";
 532          } else if (node->extract_dir) {
 533             tag = "+";
 534          } else {
 535             tag = "";
 536          }
 537          ua->send_msg("%s%s%s\n", tag, node->fname, tree_node_has_child(node)?"/":"");
 538       }
 539    }
 540    return 1;
 541 }
 542
 543 /*
 544  * Ls command that lists only the marked files
 545  */
 546 static int dot_lsmarkcmd(UAContext *ua, TREE_CTX *tree)
 547 {
 548    TREE_NODE *node;
 549    if (!tree_node_has_child(tree->node)) {
 550       return 1;
 551    }
 552    foreach_child(node, tree->node) {
 553       if ((ua->argc == 1 || fnmatch(ua->argk[1], node->fname, 0) == 0) &&
 554           (node->extract || node->extract_dir)) {
 555          ua->send_msg("%s%s\n", node->fname, tree_node_has_child(node)?"/":"");
 556       }
 557    }
 558    return 1;
 559 }
 560
 561 /*
 562  * Ls command that lists only the marked files
 563  */
 564 static void rlsmark(UAContext *ua, TREE_NODE *tnode)
 565 {
 566    TREE_NODE *node;
 567    if (!tree_node_has_child(tnode)) {
 568       return;
 569    }
 570    foreach_child(node, tnode) {
 571       if ((ua->argc == 1 || fnmatch(ua->argk[1], node->fname, 0) == 0) &&
 572           (node->extract || node->extract_dir)) {
 573          const char *tag;
 574          if (node->extract) {
 575             tag = "*";
 576          } else if (node->extract_dir) {
 577             tag = "+";
 578          } else {
 579             tag = "";
 580          }
 581          ua->send_msg("%s%s%s\n", tag, node->fname, tree_node_has_child(node)?"/":"");
 582          if (tree_node_has_child(node)) {
 583             rlsmark(ua, node);
 584          }
 585       }
 586    }
 587 }
 588
 589 static int lsmarkcmd(UAContext *ua, TREE_CTX *tree)
 590 {
 591    rlsmark(ua, tree->node);
 592    return 1;
 593 }
 594
 595 /*
 596  * This is actually the long form used for "dir"
 597  */
 598 static void ls_output(guid_list *guid, char *buf, const char *fname, const char *tag,
 599                       struct stat *statp, bool dot_cmd)
 600 {
 601    char *p;
 602    const char *f;
 603    char ec1[30];
 604    char en1[30], en2[30];
 605    int n;
 606    time_t time;
 607
 608    p = encode_mode(statp->st_mode, buf);
 609    if (dot_cmd) {
 610       *p++ = ',';
 611       n = sprintf(p, "%d,", (uint32_t)statp->st_nlink);
 612       p += n;
 613       n = sprintf(p, "%s,%s,",
 614                   guid->uid_to_name(statp->st_uid, en1, sizeof(en1)),
 615                   guid->gid_to_name(statp->st_gid, en2, sizeof(en2)));
 616       p += n;
 617       n = sprintf(p, "%s,", edit_int64(statp->st_size, ec1));
 618       p += n;
 619       p = encode_time(statp->st_mtime, p);
 620       *p++ = ',';
 621       *p++ = *tag;
 622       *p++ = ',';
 623    } else {
 624       n = sprintf(p, "  %2d ", (uint32_t)statp->st_nlink);
 625       p += n;
 626       n = sprintf(p, "%-8.8s %-8.8s",
 627                   guid->uid_to_name(statp->st_uid, en1, sizeof(en1)),
 628                   guid->gid_to_name(statp->st_gid, en2, sizeof(en2)));
 629       p += n;
 630       n = sprintf(p, "%12.12s  ", edit_int64(statp->st_size, ec1));
 631       p += n;
 632       if (statp->st_ctime > statp->st_mtime) {
 633          time = statp->st_ctime;
 634       } else {
 635          time = statp->st_mtime;
 636       }
 637       /* Display most recent time */
 638       p = encode_time(time, p);
 639       *p++ = ' ';
 640       *p++ = *tag;
 641    }
 642    for (f=fname; *f; ) {
 643       *p++ = *f++;
 644    }
 645    *p = 0;
 646 }
 647
 648 /*
 649  * Like ls command, but give more detail on each file
 650  */
 651 static int do_dircmd(UAContext *ua, TREE_CTX *tree, bool dot_cmd)
 652 {
 653    TREE_NODE *node;
 654    FILE_DBR fdbr;
 655    struct stat statp;
 656    char buf[1100];
 657    char cwd[1100], *pcwd;
 658    guid_list *guid;
 659
 660    if (!tree_node_has_child(tree->node)) {
 661       ua->send_msg(_("Node %s has no children.\n"), tree->node->fname);
 662       return 1;
 663    }
 664
 665    guid = new_guid_list();
 666    foreach_child(node, tree->node) {
 667       const char *tag;
 668       if (ua->argc == 1 || fnmatch(ua->argk[1], node->fname, 0) == 0) {
 669          if (node->extract) {
 670             tag = "*";
 671          } else if (node->extract_dir) {
 672             tag = "+";
 673          } else {
 674             tag = " ";
 675          }
 676          tree_getpath(node, cwd, sizeof(cwd));
 677          fdbr.FileId = 0;
 678          fdbr.JobId = node->JobId;
 679          /*
 680           * Strip / from soft links to directories.
 681           *   This is because soft links to files have a trailing slash
 682           *   when returned from tree_getpath, but db_get_file_attr...
 683           *   treats soft links as files, so they do not have a trailing
 684           *   slash like directory names.
 685           */
 686          if (node->type == TN_FILE && tree_node_has_child(node)) {
 687             bstrncpy(buf, cwd, sizeof(buf));
 688             pcwd = buf;
 689             int len = strlen(buf);
 690             if (len > 1) {
 691                buf[len-1] = 0;        /* strip trailing / */
 692             }
 693          } else {
 694             pcwd = cwd;
 695          }
 696          if (db_get_file_attributes_record(ua->jcr, ua->db, pcwd, NULL, &fdbr)) {
 697             int32_t LinkFI;
 698             decode_stat(fdbr.LStat, &statp, &LinkFI); /* decode stat pkt */
 699          } else {
 700             /* Something went wrong getting attributes -- print name */
 701             memset(&statp, 0, sizeof(statp));
 702          }
 703          ls_output(guid, buf, cwd, tag, &statp, dot_cmd);
 704          ua->send_msg("%s\n", buf);
 705       }
 706    }
 707    free_guid_list(guid);
 708    return 1;
 709 }
 710
 711 int dot_dircmd(UAContext *ua, TREE_CTX *tree)
 712 {
 713    return do_dircmd(ua, tree, true/*dot command*/);
 714 }
 715
 716 static int dircmd(UAContext *ua, TREE_CTX *tree)
 717 {
 718    return do_dircmd(ua, tree, false/*not dot command*/);
 719 }
 720
 721
 722 static int estimatecmd(UAContext *ua, TREE_CTX *tree)
 723 {
 724    int total, num_extract;
 725    uint64_t total_bytes = 0;
 726    FILE_DBR fdbr;
 727    struct stat statp;
 728    char cwd[1100];
 729    char ec1[50];
 730
 731    total = num_extract = 0;
 732    for (TREE_NODE *node=first_tree_node(tree->root); node; node=next_tree_node(node)) {
 733       if (node->type != TN_NEWDIR) {
 734          total++;
 735          /* If regular file, get size */
 736          if (node->extract && node->type == TN_FILE) {
 737             num_extract++;
 738             tree_getpath(node, cwd, sizeof(cwd));
 739             fdbr.FileId = 0;
 740             fdbr.JobId = node->JobId;
 741             if (db_get_file_attributes_record(ua->jcr, ua->db, cwd, NULL, &fdbr)) {
 742                int32_t LinkFI;
 743                decode_stat(fdbr.LStat, &statp, &LinkFI); /* decode stat pkt */
 744                if (S_ISREG(statp.st_mode) && statp.st_size > 0) {
 745                   total_bytes += statp.st_size;
 746                }
 747             }
 748          /* Directory, count only */
 749          } else if (node->extract || node->extract_dir) {
 750             num_extract++;
 751          }
 752       }
 753    }
 754    ua->send_msg(_("%d total files; %d marked to be restored; %s bytes.\n"),
 755             total, num_extract, edit_uint64_with_commas(total_bytes, ec1));
 756    return 1;
 757 }
 758
 759
 760
 761 static int helpcmd(UAContext *ua, TREE_CTX *tree)
 762 {
 763    unsigned int i;
 764
 765    ua->send_msg(_("  Command    Description\n  =======    ===========\n"));
 766    for (i=0; i<comsize; i++) {
 767       /* List only non-dot commands */
 768       if (commands[i].key[0] != '.') {
 769          ua->send_msg("  %-10s %s\n", _(commands[i].key), _(commands[i].help));
 770       }
 771    }
 772    ua->send_msg("\n");
 773    return 1;
 774 }
 775
 776 /*
 777  * Change directories.  Note, if the user specifies x: and it fails,
 778  *   we assume it is a Win32 absolute cd rather than relative and
 779  *   try a second time with /x: ...  Win32 kludge.
 780  */
 781 static int cdcmd(UAContext *ua, TREE_CTX *tree)
 782 {
 783    TREE_NODE *node;
 784    char cwd[2000];
 785
 786
 787    if (ua->argc != 2) {
 788       ua->error_msg(_("Too few or too many arguments. Try using double quotes.\n"));
 789       return 1;
 790    }
 791    node = tree_cwd(ua->argk[1], tree->root, tree->node);
 792    if (!node) {
 793       /* Try once more if Win32 drive -- make absolute */
 794       if (ua->argk[1][1] == ':') {  /* win32 drive */
 795          bstrncpy(cwd, "/", sizeof(cwd));
 796          bstrncat(cwd, ua->argk[1], sizeof(cwd));
 797          node = tree_cwd(cwd, tree->root, tree->node);
 798       }
 799       if (!node) {
 800          ua->warning_msg(_("Invalid path given.\n"));
 801       } else {
 802          tree->node = node;
 803       }
 804    } else {
 805       tree->node = node;
 806    }
 807    return pwdcmd(ua, tree);
 808 }
 809
 810 static int pwdcmd(UAContext *ua, TREE_CTX *tree)
 811 {
 812    char cwd[2000];
 813    tree_getpath(tree->node, cwd, sizeof(cwd));
 814    if (ua->api) {
 815       ua->send_msg("%s", cwd);
 816    } else {
 817       ua->send_msg(_("cwd is: %s\n"), cwd);
 818    }
 819    return 1;
 820 }
 821
 822 static int dot_pwdcmd(UAContext *ua, TREE_CTX *tree)
 823 {
 824    char cwd[2000];
 825    tree_getpath(tree->node, cwd, sizeof(cwd));
 826    ua->send_msg("%s", cwd);
 827    return 1;
 828 }
 829
 830 static int unmarkcmd(UAContext *ua, TREE_CTX *tree)
 831 {
 832    TREE_NODE *node;
 833    int count = 0;
 834
 835    if (ua->argc < 2 || !tree_node_has_child(tree->node)) {
 836       ua->send_msg(_("No files unmarked.\n"));
 837       return 1;
 838    }
 839    for (int i=1; i < ua->argc; i++) {
 840       strip_trailing_slash(ua->argk[i]);
 841       foreach_child(node, tree->node) {
 842          if (fnmatch(ua->argk[i], node->fname, 0) == 0) {
 843             count += set_extract(ua, node, tree, false);
 844          }
 845       }
 846    }
 847    if (count == 0) {
 848       ua->send_msg(_("No files unmarked.\n"));
 849    } else if (count == 1) {
 850       ua->send_msg(_("1 file unmarked.\n"));
 851    } else {
 852       char ed1[50];
 853       ua->send_msg(_("%s files unmarked.\n"), edit_uint64_with_commas(count, ed1));
 854    }
 855    return 1;
 856 }
 857
 858 static int unmarkdircmd(UAContext *ua, TREE_CTX *tree)
 859 {
 860    TREE_NODE *node;
 861    int count = 0;
 862
 863    if (ua->argc < 2 || !tree_node_has_child(tree->node)) {
 864       ua->send_msg(_("No directories unmarked.\n"));
 865       return 1;
 866    }
 867
 868    for (int i=1; i < ua->argc; i++) {
 869       strip_trailing_slash(ua->argk[i]);
 870       foreach_child(node, tree->node) {
 871          if (fnmatch(ua->argk[i], node->fname, 0) == 0) {
 872             if (node->type == TN_DIR || node->type == TN_DIR_NLS) {
 873                node->extract_dir = false;
 874                count++;
 875             }
 876          }
 877       }
 878    }
 879
 880    if (count == 0) {
 881       ua->send_msg(_("No directories unmarked.\n"));
 882    } else if (count == 1) {
 883       ua->send_msg(_("1 directory unmarked.\n"));
 884    } else {
 885       ua->send_msg(_("%d directories unmarked.\n"), count);
 886    }
 887    return 1;
 888 }
 889
 890
 891 static int donecmd(UAContext *ua, TREE_CTX *tree)
 892 {
 893    return 0;
 894 }
 895
 896 static int quitcmd(UAContext *ua, TREE_CTX *tree)
 897 {
 898    ua->quit = true;
 899    return 0;
 900 }