Line data    Source code

       1             : #include "../burp.h"
       2             : #include "../alloc.h"
       3             : #include "../cntr.h"
       4             : #include "../conf.h"
       5             : #include "../cstat.h"
       6             : #include "../fsops.h"
       7             : #include "../handy.h"
       8             : #include "../log.h"
       9             : #include "../sbuf.h"
      10             : #include "compress.h"
      11             : #include "manio.h"
      12             : #include "sdirs.h"
      13             : #include "child.h"
      14             : #include "backup_phase3.h"
      15             : 
      16           3 : static const char *get_rmanifest_relative(struct sdirs *sdirs,
      17             :         struct conf **confs)
      18             : {
      19             :         const char *cp;
      20           3 :         cp=sdirs->rmanifest+strlen(get_string(confs[OPT_DIRECTORY]));
      21           0 :         while(cp && *cp=='/') cp++;
      22           3 :         return cp;
      23             : }
      24             : 
      25             : // Combine the phase1 and phase2 files into a new manifest.
      26           8 : int backup_phase3_server_all(struct sdirs *sdirs, struct conf **confs)
      27             : {
      28           5 :         int ret=-1;
      29           5 :         int pcmp=0;
      30           5 :         struct sbuf *usb=NULL;
      31           5 :         struct sbuf *csb=NULL;
      32           5 :         char *manifesttmp=NULL;
      33           5 :         struct manio *newmanio=NULL;
      34           5 :         struct manio *chmanio=NULL;
      35           5 :         struct manio *unmanio=NULL;
      36           5 :         enum protocol protocol=get_protocol(confs);
      37           5 :         struct cntr *cntr=get_cntr(confs);
      38           5 :         const char *rmanifest_relative=NULL;
      39             : 
      40           5 :         logp("Begin phase3 (merge manifests)\n");
      41             : 
      42           5 :         if(protocol==PROTO_2)
      43           3 :                 rmanifest_relative=get_rmanifest_relative(sdirs, confs);
      44             : 
      45           5 :         if(!(manifesttmp=get_tmp_filename(sdirs->manifest))
      46           5 :           || !(newmanio=manio_open_phase3(manifesttmp,
      47           5 :                 comp_level(get_int(confs[OPT_COMPRESSION])),
      48             :                 protocol, rmanifest_relative))
      49           5 :           || !(chmanio=manio_open_phase2(sdirs->changed, "rb", protocol))
      50           5 :           || !(unmanio=manio_open_phase2(sdirs->unchanged, "rb", protocol))
      51           5 :           || !(usb=sbuf_alloc(protocol))
      52           5 :           || !(csb=sbuf_alloc(protocol)))
      53             :                 goto end;
      54             : 
      55          25 :         while(chmanio || unmanio)
      56             :         {
      57          20 :                 if(unmanio
      58          17 :                   && !usb->path.buf)
      59             :                 {
      60           9 :                         switch(manio_read(unmanio, usb))
      61             :                         {
      62             :                                 case -1: goto end;
      63           3 :                                 case 1: manio_close(&unmanio);
      64             :                         }
      65             :                 }
      66             : 
      67          20 :                 if(chmanio
      68          18 :                   && !csb->path.buf)
      69             :                 {
      70           9 :                         switch(manio_read(chmanio, csb))
      71             :                         {
      72             :                                 case -1: goto end;
      73           2 :                                 case 1: manio_close(&chmanio);
      74             :                         }
      75             :                 }
      76             : 
      77          20 :                 if(usb->path.buf && !csb->path.buf)
      78             :                 {
      79           2 :                         if(write_status(CNTR_STATUS_MERGING,
      80             :                                 usb->path.buf, cntr)) goto end;
      81           2 :                         switch(manio_copy_entry(usb, usb, unmanio, newmanio))
      82             :                         {
      83             :                                 case -1: goto end;
      84           1 :                                 case 1: manio_close(&unmanio);
      85             :                         }
      86             :                 }
      87          18 :                 else if(!usb->path.buf && csb->path.buf)
      88             :                 {
      89           4 :                         if(write_status(CNTR_STATUS_MERGING,
      90             :                                 csb->path.buf, cntr)) goto end;
      91           4 :                         switch(manio_copy_entry(csb, csb, chmanio, newmanio))
      92             :                         {
      93             :                                 case -1: goto end;
      94           2 :                                 case 1: manio_close(&chmanio);
      95             :                         }
      96             :                 }
      97          14 :                 else if(!usb->path.buf && !csb->path.buf)
      98             :                 {
      99           2 :                         continue;
     100             :                 }
     101          12 :                 else if(!(pcmp=sbuf_pathcmp(usb, csb)))
     102             :                 {
     103             :                         // They were the same - write one.
     104           0 :                         if(write_status(CNTR_STATUS_MERGING,
     105           0 :                                 csb->path.buf, cntr)) goto end;
     106           0 :                         switch(manio_copy_entry(csb, csb, chmanio, newmanio))
     107             :                         {
     108             :                                 case -1: goto end;
     109           0 :                                 case 1: manio_close(&chmanio);
     110             :                         }
     111             :                 }
     112          12 :                 else if(pcmp<0)
     113             :                 {
     114           6 :                         if(write_status(CNTR_STATUS_MERGING,
     115           6 :                                 usb->path.buf, cntr)) goto end;
     116           6 :                         switch(manio_copy_entry(usb, usb, unmanio, newmanio))
     117             :                         {
     118             :                                 case -1: goto end;
     119           1 :                                 case 1: manio_close(&unmanio);
     120             :                         }
     121             :                 }
     122             :                 else
     123             :                 {
     124           6 :                         if(write_status(CNTR_STATUS_MERGING,
     125           6 :                                 csb->path.buf, cntr)) goto end;
     126           6 :                         switch(manio_copy_entry(csb, csb, chmanio, newmanio))
     127             :                         {
     128             :                                 case -1: goto end;
     129           1 :                                 case 1: manio_close(&chmanio);
     130             :                         }
     131             :                 }
     132             :         }
     133             : 
     134             :         // Flush to disk.
     135           5 :         if(manio_close(&newmanio))
     136             :         {
     137           0 :                 logp("error gzclosing %s in backup_phase3_server\n",
     138             :                         manifesttmp);
     139           0 :                 goto end;
     140             :         }
     141             : 
     142             :         // Rename race condition should be of no consequence here, as the
     143             :         // manifest should just get recreated automatically.
     144           5 :         if(do_rename(manifesttmp, sdirs->manifest))
     145             :                 goto end;
     146             :         else
     147             :         {
     148           5 :                 recursive_delete(sdirs->changed);
     149           5 :                 recursive_delete(sdirs->unchanged);
     150             :         }
     151             : 
     152           5 :         logp("End phase3 (merge manifests)\n");
     153           5 :         ret=0;
     154             : end:
     155           5 :         manio_close(&newmanio);
     156           5 :         manio_close(&chmanio);
     157           5 :         manio_close(&unmanio);
     158           5 :         sbuf_free(&csb);
     159           5 :         sbuf_free(&usb);
     160           5 :         free_w(&manifesttmp);
     161           5 :         return ret;
     162             : }