git.sur5r.net Git - bacula/bacula/blob - bacula/src/filed/restore.c

   1 /*
   2  *  Bacula File Daemon  restore.c Restorefiles.
   3  *
   4  *    Kern Sibbald, November MM
   5  *
   6  *   Version $Id$
   7  *
   8  */
   9 /*
  10    Copyright (C) 2000, 2001, 2002 Kern Sibbald and John Walker
  11
  12    This program is free software; you can redistribute it and/or
  13    modify it under the terms of the GNU General Public License as
  14    published by the Free Software Foundation; either version 2 of
  15    the License, or (at your option) any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  20    General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public
  23    License along with this program; if not, write to the Free
  24    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  25    MA 02111-1307, USA.
  26
  27  */
  28
  29 #include "bacula.h"
  30 #include "filed.h"
  31
  32 /* Data received from Storage Daemon */
  33 static char rec_header[] = "rechdr %ld %ld %ld %ld %ld";
  34
  35 /* Forward referenced functions */
  36 static void print_ls_output(JCR *jcr, char *fname, char *lname, int type, struct stat *statp);
  37
  38 #define RETRY 10                      /* retry wait time */
  39
  40 /*
  41  * Restore the requested files.
  42  *
  43  */
  44 void do_restore(JCR *jcr)
  45 {
  46    int wherelen;
  47    BSOCK *sd;
  48    POOLMEM *fname;                    /* original file name */
  49    POOLMEM *ofile;                    /* output name with possible prefix */
  50    POOLMEM *lname;                    /* link name */
  51    int32_t stream;
  52    uint32_t size;
  53    uint32_t VolSessionId, VolSessionTime, file_index;
  54    uint32_t record_file_index;
  55    struct stat statp;
  56    int extract = FALSE;
  57    int ofd = -1;
  58    int type;
  59    uint32_t total = 0;
  60
  61    wherelen = strlen(jcr->where);
  62
  63    sd = jcr->store_bsock;
  64    jcr->JobStatus = JS_Running;
  65
  66    if (!bnet_set_buffer_size(sd, MAX_NETWORK_BUFFER_SIZE, BNET_SETBUF_READ)) {
  67       return;
  68    }
  69    jcr->buf_size = sd->msglen;
  70
  71    fname = get_pool_memory(PM_FNAME);
  72    ofile = get_pool_memory(PM_FNAME);
  73    lname = get_pool_memory(PM_FNAME);
  74
  75 #ifdef HAVE_LIBZ
  76    uint32_t compress_buf_size = jcr->buf_size + 12 + ((jcr->buf_size+999) / 1000) + 100;
  77    jcr->compress_buf = (char *)bmalloc(compress_buf_size);
  78 #endif
  79
  80    /*
  81     * Get a record from the Storage daemon
  82     */
  83    while (bnet_recv(sd) > 0 && !job_cancelled(jcr)) {
  84       /*
  85        * First we expect a Stream Record Header
  86        */
  87       if (sscanf(sd->msg, rec_header, &VolSessionId, &VolSessionTime, &file_index,
  88           &stream, &size) != 5) {
  89          Jmsg1(jcr, M_FATAL, 0, _("Record header scan error: %s\n"), sd->msg);
  90          goto bail_out;
  91       }
  92       Dmsg2(30, "Got hdr: FilInx=%d Stream=%d.\n", file_index, stream);
  93
  94       /*
  95        * Now we expect the Stream Data
  96        */
  97       if (bnet_recv(sd) < 0 && !job_cancelled(jcr)) {
  98          Jmsg1(jcr, M_FATAL, 0, _("Data record error. ERR=%s\n"), bnet_strerror(sd));
  99       }
 100       if (size != ((uint32_t) sd->msglen)) {
 101          Jmsg2(jcr, M_FATAL, 0, _("Actual data size %d not same as header %d\n"), sd->msglen, size);
 102          goto bail_out;
 103       }
 104       Dmsg1(30, "Got stream data, len=%d\n", sd->msglen);
 105
 106       /* File Attributes stream */
 107       if (stream == STREAM_UNIX_ATTRIBUTES) {
 108          char *ap, *lp, *fp;
 109
 110          Dmsg1(30, "Stream=Unix Attributes. extract=%d\n", extract);
 111          /* If extracting, it was from previous stream, so
 112           * close the output file.
 113           */
 114          if (extract) {
 115             if (ofd < 0) {
 116                Emsg0(M_ABORT, 0, _("Logic error output file should be open\n"));
 117             }
 118             close(ofd);
 119             ofd = -1;
 120             extract = FALSE;
 121             set_statp(jcr, fname, ofile, lname, type, &statp);
 122             Dmsg0(30, "Stop extracting.\n");
 123          }
 124
 125          if ((int)sizeof_pool_memory(fname) <  sd->msglen) {
 126             fname = realloc_pool_memory(fname, sd->msglen + 1);
 127          }
 128          if (sizeof_pool_memory(ofile) < sizeof_pool_memory(fname) + wherelen + 1) {
 129             ofile = realloc_pool_memory(ofile, sizeof_pool_memory(fname) + wherelen + 1);
 130          }
 131          if ((int)sizeof_pool_memory(lname) < sd->msglen) {
 132             lname = realloc_pool_memory(lname, sd->msglen + 1);
 133          }
 134          *fname = 0;
 135          *lname = 0;
 136
 137          /*
 138           * An Attributes record consists of:
 139           *    File_index
 140           *    Type   (FT_types)
 141           *    Filename
 142           *    Attributes
 143           *    Link name (if file linked i.e. FT_LNK)
 144           *
 145           */
 146          if (sscanf(sd->msg, "%d %d", &record_file_index, &type) != 2) {
 147             Jmsg(jcr, M_FATAL, 0, _("Error scanning record header: %s\n"), sd->msg);
 148             Dmsg0(0, "\nError scanning header\n");
 149             goto bail_out;
 150          }
 151          Dmsg2(30, "Got Attr: FilInx=%d type=%d\n", record_file_index, type);
 152          if (record_file_index != file_index) {
 153             Jmsg(jcr, M_FATAL, 0, _("Record header file index %ld not equal record index %ld\n"),
 154                file_index, record_file_index);
 155             Dmsg0(0, "File index error\n");
 156             goto bail_out;
 157          }
 158          ap = sd->msg;
 159          while (*ap++ != ' ')         /* skip record file index */
 160             ;
 161          while (*ap++ != ' ')         /* skip type */
 162             ;
 163          /* Save filename and position to attributes */
 164          fp = fname;
 165          while (*ap != 0) {
 166             *fp++  = *ap++;           /* copy filename to fname */
 167          }
 168          *fp = *ap++;                 /* terminate filename & point to attribs */
 169
 170          /* Skip to Link name */
 171          if (type == FT_LNK) {
 172             lp = ap;
 173             while (*lp++ != 0) {
 174                ;
 175             }
 176             strcat(lname, lp);        /* "save" link name */
 177          } else {
 178             *lname = 0;
 179          }
 180
 181          decode_stat(ap, &statp);
 182          /*
 183           * Prepend the where directory so that the
 184           * files are put where the user wants.
 185           *
 186           * We do a little jig here to handle Win32 files with
 187           * a drive letter.
 188           *   If where is null and we are running on a win32 client,
 189           *      change nothing.
 190           *   Otherwise, if the second character of the filename is a
 191           *   colon (:), change it into a slash (/) -- this creates
 192           *   a reasonable pathname on most systems.
 193           */
 194          if (jcr->where[0] == 0 && win32_client) {
 195             strcpy(ofile, fname);
 196          } else {
 197             strcpy(ofile, jcr->where);
 198             if (fname[1] == ':') {
 199                fname[1] = '/';
 200                strcat(ofile, fname);
 201                fname[1] = ':';
 202             } else {
 203                strcat(ofile, fname);
 204             }
 205          }
 206
 207          Dmsg1(30, "Outfile=%s\n", ofile);
 208          print_ls_output(jcr, ofile, lname, type, &statp);
 209
 210          extract = create_file(jcr, fname, ofile, lname, type, &statp, &ofd);
 211          Dmsg1(40, "Extract=%d\n", extract);
 212          if (extract) {
 213             jcr->JobFiles++;
 214          }
 215          jcr->num_files_examined++;
 216
 217       /* Data stream */
 218       } else if (stream == STREAM_FILE_DATA) {
 219          if (extract) {
 220             Dmsg2(30, "Write %d bytes, total before write=%d\n", sd->msglen, total);
 221             if (write(ofd, sd->msg, sd->msglen) != sd->msglen) {
 222                Dmsg0(0, "===Write error===\n");
 223                Jmsg2(jcr, M_ERROR, 0, "Write error on %s: %s\n", ofile, strerror(errno));
 224                goto bail_out;
 225             }
 226             total += sd->msglen;
 227             jcr->JobBytes += sd->msglen;
 228          }
 229
 230       /* GZIP data stream */
 231       } else if (stream == STREAM_GZIP_DATA) {
 232 #ifdef HAVE_LIBZ
 233          if (extract) {
 234             uLong compress_len;
 235             int stat;
 236
 237             compress_len = compress_buf_size;
 238             Dmsg2(100, "Comp_len=%d msglen=%d\n", compress_len, sd->msglen);
 239             if ((stat=uncompress((Byte *)jcr->compress_buf, &compress_len,
 240                   (const Byte *)sd->msg, (uLong)sd->msglen)) != Z_OK) {
 241                Jmsg(jcr, M_ERROR, 0, _("Uncompression error. ERR=%d\n"), stat);
 242                goto bail_out;
 243             }
 244
 245             Dmsg2(100, "Write uncompressed %d bytes, total before write=%d\n", compress_len, total);
 246             if ((uLong)write(ofd, jcr->compress_buf, compress_len) != compress_len) {
 247                Dmsg0(0, "===Write error===\n");
 248                Jmsg2(jcr, M_ERROR, 0, "Write error on %s: %s\n", ofile, strerror(errno));
 249                goto bail_out;
 250             }
 251             total += compress_len;
 252             jcr->JobBytes += compress_len;
 253          }
 254 #else
 255          if (extract) {
 256             Jmsg(jcr, M_ERROR, 0, "GZIP data stream found, but GZIP not configured!\n");
 257             goto bail_out;
 258          }
 259 #endif
 260       /* If extracting, wierd stream (not 1 or 2), close output file anyway */
 261       } else if (extract) {
 262          Dmsg1(30, "Found wierd stream %d\n", stream);
 263          if (ofd < 0) {
 264             Emsg0(M_ABORT, 0, _("Logic error output file should be open\n"));
 265          }
 266          close(ofd);
 267          ofd = -1;
 268          extract = FALSE;
 269          set_statp(jcr, fname, ofile, lname, type, &statp);
 270       } else if (stream != STREAM_MD5_SIGNATURE) {
 271          Dmsg2(0, "None of above!!! stream=%d data=%s\n", stream,sd->msg);
 272       }
 273    }
 274
 275    /* If output file is still open, it was the last one in the
 276     * archive since we just hit an end of file, so close the file.
 277     */
 278    if (ofd >= 0) {
 279       close(ofd);
 280       set_statp(jcr, fname, ofile, lname, type, &statp);
 281    }
 282    jcr->JobStatus = JS_Terminated;
 283    goto ok_out;
 284
 285 bail_out:
 286    jcr->JobStatus = JS_ErrorTerminated;
 287 ok_out:
 288    if (jcr->compress_buf) {
 289       free(jcr->compress_buf);
 290       jcr->compress_buf = NULL;
 291    }
 292    free_pool_memory(fname);
 293    free_pool_memory(ofile);
 294    free_pool_memory(lname);
 295    Dmsg2(10, "End Do Restore. Files=%d Bytes=%" lld "\n", jcr->JobFiles,
 296       jcr->JobBytes);
 297 }
 298
 299 extern char *getuser(uid_t uid);
 300 extern char *getgroup(gid_t gid);
 301
 302 /*
 303  * Print an ls style message, also send INFO
 304  */
 305 static void print_ls_output(JCR *jcr, char *fname, char *lname, int type, struct stat *statp)
 306 {
 307    char buf[2000];
 308    char ec1[30];
 309    char *p, *f;
 310    int n;
 311
 312    p = encode_mode(statp->st_mode, buf);
 313    n = sprintf(p, "  %2d ", (uint32_t)statp->st_nlink);
 314    p += n;
 315    n = sprintf(p, "%-8.8s %-8.8s", getuser(statp->st_uid), getgroup(statp->st_gid));
 316    p += n;
 317    n = sprintf(p, "%8.8s ", edit_uint64(statp->st_size, ec1));
 318    p += n;
 319    p = encode_time(statp->st_ctime, p);
 320    *p++ = ' ';
 321    *p++ = ' ';
 322    for (f=fname; *f && (p-buf) < (int)sizeof(buf); )
 323       *p++ = *f++;
 324    if (type == FT_LNK) {
 325       *p++ = ' ';
 326       *p++ = '-';
 327       *p++ = '>';
 328       *p++ = ' ';
 329       /* Copy link name */
 330       for (f=lname; *f && (p-buf) < (int)sizeof(buf); )
 331          *p++ = *f++;
 332    }
 333    *p++ = '\n';
 334    *p = 0;
 335    Dmsg0(20, buf);
 336    Jmsg(jcr, M_INFO, 0, buf);
 337 }