LCOV - code coverage report
Current view: top level - src/server - resume.c (source / functions) Hit Total Coverage
Test: burp-coverage-clean.info Lines: 77 304 25.3 %
Date: 2020-08-31 23:02:24 Functions: 3 10 30.0 %

          Line data    Source code
       1             : #include "../burp.h"
       2             : #include "../cmd.h"
       3             : #include "../cntr.h"
       4             : #include "../iobuf.h"
       5             : #include "../log.h"
       6             : #include "../pathcmp.h"
       7             : #include "../sbuf.h"
       8             : #include "dpth.h"
       9             : #include "resume.h"
      10             : #include "backup_phase1.h"
      11             : #include "protocol1/dpth.h"
      12             : 
      13             : // Used on resume, this just reads the phase1 file and sets up cntr.
      14           0 : static int read_phase1(struct manio *p1manio, struct conf **cconfs)
      15             : {
      16           0 :         int ret=-1;
      17             :         struct sbuf *p1b;
      18           0 :         enum protocol protocol=get_protocol(cconfs);
      19           0 :         struct cntr *cntr=get_cntr(cconfs);
      20           0 :         if(!(p1b=sbuf_alloc(protocol))) return -1;
      21             :         while(1)
      22             :         {
      23           0 :                 sbuf_free_content(p1b);
      24           0 :                 switch(manio_read(p1manio, p1b))
      25             :                 {
      26             :                         case 0: break;
      27           0 :                         case 1: ret=0;
      28             :                         default: goto end;
      29             :                 }
      30           0 :                 cntr_add_phase1(cntr, p1b->path.cmd, 0);
      31             : 
      32           0 :                 if(sbuf_is_estimatable(p1b))
      33           0 :                         cntr_add_val(cntr, CMD_BYTES_ESTIMATED,
      34           0 :                                 (uint64_t)p1b->statp.st_size);
      35             :         }
      36             : end:
      37           0 :         sbuf_free(&p1b);
      38           0 :         return ret;
      39             : }
      40             : 
      41           0 : static int set_higher_datapth(struct sbuf *sb, struct dpth *dpth)
      42             : {
      43             :         // Make sure we end up with the highest datapth we can possibly
      44             :         // find - dpth_protocol1_set_from_string() will only set it if
      45             :         // it is higher.
      46           0 :         if(sb->protocol1 && sb->protocol1->datapth.buf
      47           0 :           && dpth_protocol1_set_from_string(dpth,
      48             :                 sb->protocol1->datapth.buf))
      49             :         {
      50           0 :                 logp("unable to set datapath: %s\n",
      51           0 :                         iobuf_to_printable(&sb->protocol1->datapth));
      52             :                 return -1;
      53             :         }
      54             :         return 0;
      55             : }
      56             : 
      57             : #ifndef UTEST
      58             : static
      59             : #endif
      60          48 : int forward_past_entry(struct manio *manio, struct iobuf *target,
      61             :         enum protocol protocol, man_off_t **pos)
      62             : {
      63          48 :         struct sbuf *sb=NULL;
      64             : 
      65          48 :         if(!(sb=sbuf_alloc(protocol)))
      66             :                 goto error;
      67             : 
      68          48 :         man_off_t_free(pos);
      69          48 :         if(!(*pos=manio_tell(manio)))
      70             :         {
      71           0 :                 logp("Could not manio_tell first pos in %s(): %s\n",
      72           0 :                         __func__, strerror(errno));
      73           0 :                 goto error;
      74             :         }
      75             : 
      76             :         while(1)
      77             :         {
      78        1744 :                 sbuf_free_content(sb);
      79        1744 :                 man_off_t_free(pos);
      80        1744 :                 if(!(*pos=manio_tell(manio)))
      81             :                 {
      82           0 :                         logp("Could not manio_tell top pos in %s(): %s\n",
      83           0 :                                 __func__, strerror(errno));
      84           0 :                         goto error;
      85             :                 }
      86             : 
      87        1744 :                 switch(manio_read(manio, sb))
      88             :                 {
      89             :                         case 0:
      90             :                                 break;
      91             :                         case 1:
      92           0 :                                 if(!(*pos)->offset)
      93             :                                 {
      94             :                                         // This is OK. I've seen it happen
      95             :                                         // when the current manifest is an
      96             :                                         // empty backup.
      97           0 :                                         logp("Empty file in %s()\n", __func__);
      98           0 :                                         sbuf_free(&sb);
      99           0 :                                         return 0;
     100             :                                 }
     101           0 :                                 logp("End of file in %s()\n", __func__);
     102           0 :                                 goto error;
     103             :                         default:
     104           0 :                                 logp("Error in %s()\n", __func__);
     105           0 :                                 goto error;
     106             :                 }
     107             : 
     108        1744 :                 switch(iobuf_pathcmp(target, &sb->path))
     109             :                 {
     110             :                         case 0:
     111             :                                 // Exact match, we want to be past here.
     112          48 :                                 if(protocol==PROTO_2
     113          24 :                                   && manio->phase==0
     114           0 :                                   && !sb->endfile.buf)
     115             :                                 {
     116             :                                         // This is the current manio, and we
     117             :                                         // need one more read to get us past
     118             :                                         // endfile.
     119           0 :                                         sbuf_free_content(sb);
     120           0 :                                         switch(manio_read(manio, sb))
     121             :                                         {
     122             :                                                 case 0:
     123             :                                                         break;
     124             :                                                 case 1:
     125           0 :                                                         logp("End of file finishing up in %s()\n", __func__);
     126           0 :                                                         goto error;
     127             :                                                 default:
     128           0 :                                                         logp("Error finishing up in %s()\n", __func__);
     129           0 :                                                         goto error;
     130             :                                         }
     131           0 :                                         if(sb->path.buf)
     132             :                                         {
     133           0 :                                                 logp("Not expecting %s in %s()\n",
     134             :                                                         iobuf_to_printable(&sb->path),
     135             :                                                         __func__);
     136           0 :                                                 goto error;
     137             :                                         }
     138           0 :                                         if(!sb->endfile.buf)
     139             :                                         {
     140           0 :                                                 logp("Was expecting endfile in %s()\n",
     141             :                                                         __func__);
     142           0 :                                                 goto error;
     143             :                                         }
     144             :                                         // Drop through to tell the position.
     145             :                                 }
     146          48 :                                 man_off_t_free(pos);
     147          48 :                                 if(!(*pos=manio_tell(manio)))
     148             :                                 {
     149           0 :                                         logp("Could not manio_tell pos in %s(): "
     150           0 :                                                 "%s\n", __func__, strerror(errno));
     151           0 :                                         goto error;
     152             :                                 }
     153          48 :                                 sbuf_free(&sb);
     154          48 :                                 return 0;
     155             :                         case -1:
     156             :                                 // Gone past the match, we want to return to
     157             :                                 // the previous tell.
     158           0 :                                 sbuf_free(&sb);
     159           0 :                                 return 0;
     160             :                         default:
     161             :                                 // Not gone far enough yet, continue.
     162             :                                 break;
     163             :                 }
     164             :         }
     165             : 
     166             : error:
     167           0 :         sbuf_free(&sb);
     168           0 :         man_off_t_free(pos);
     169           0 :         return -1;
     170             : }
     171             : 
     172             : #ifndef UTEST
     173             : static
     174             : #endif
     175          88 : int forward_before_entry(struct manio *manio, struct iobuf *target,
     176             :         struct cntr *cntr, struct dpth *dpth, enum protocol protocol,
     177             :         man_off_t **pos)
     178             : {
     179          88 :         int ars=0;
     180          88 :         struct sbuf *sb=NULL;
     181             : 
     182          88 :         if(!(sb=sbuf_alloc(protocol)))
     183             :                 goto error;
     184             : 
     185          88 :         man_off_t_free(pos);
     186          88 :         if(!(*pos=manio_tell(manio)))
     187             :         {
     188           0 :                 logp("Could not manio_tell first pos in %s(): %s\n",
     189           0 :                         __func__, strerror(errno));
     190           0 :                 goto error;
     191             :         }
     192             : 
     193             :         while(1)
     194             :         {
     195        6380 :                 if(sb->endfile.buf
     196        2208 :                   || (sb->path.buf && !sbuf_is_filedata(sb)))
     197             :                 {
     198        4240 :                         man_off_t_free(pos);
     199        4240 :                         if(!(*pos=manio_tell(manio)))
     200             :                         {
     201           0 :                                 logp("Could not manio_tell pos in %s(): "
     202           0 :                                         "%s\n", __func__, strerror(errno));
     203           0 :                                 goto error;
     204             :                         }
     205             :                 }
     206             : 
     207        6380 :                 sbuf_free_content(sb);
     208        6380 :                 ars=manio_read(manio, sb);
     209        6380 :                 if(dpth && set_higher_datapth(sb, dpth)) goto error;
     210             : 
     211        6380 :                 switch(ars)
     212             :                 {
     213             :                         case 0: break;
     214             :                         case 1:
     215           6 :                                 sbuf_free(&sb);
     216           6 :                                 return 0;
     217             :                         default:
     218          10 :                                 logp("Error in %s(), but continuing\n",
     219             :                                         __func__);
     220             :                                 // Treat error in unchanged manio as
     221             :                                 // OK - could have been a short write.
     222          10 :                                 sbuf_free(&sb);
     223          10 :                                 return 0;
     224             :                 }
     225             : 
     226        6364 :                 if(iobuf_pathcmp(target, &sb->path)<=0)
     227             :                 {
     228          72 :                         sbuf_free(&sb);
     229          72 :                         return 0;
     230             :                 }
     231             : 
     232        6292 :                 if(cntr)
     233             :                 {
     234           0 :                         if(sb->endfile.buf)
     235             :                         {
     236           0 :                                 uint64_t e=strtoull(sb->endfile.buf, NULL, 10);
     237           0 :                                 cntr_add_bytes(cntr, e);
     238             :                         }
     239             :                 }
     240             :         }
     241             : 
     242             : error:
     243           0 :         sbuf_free(&sb);
     244           0 :         man_off_t_free(pos);
     245           0 :         return -1;
     246             : }
     247             : 
     248             : #ifndef UTEST
     249             : static
     250             : #endif
     251         208 : int get_last_good_entry(struct manio *manio, struct iobuf *result,
     252             :         struct cntr *cntr, struct dpth *dpth, enum protocol protocol,
     253             :         man_off_t **pos)
     254             : {
     255         208 :         int ars=0;
     256         208 :         int got_vss_start=0;
     257         208 :         struct sbuf *sb=NULL;
     258             :         struct iobuf lastpath;
     259             : 
     260         208 :         if(!(sb=sbuf_alloc(protocol)))
     261             :                 goto error;
     262             : 
     263         208 :         iobuf_init(&lastpath);
     264             : 
     265         208 :         man_off_t_free(pos);
     266         208 :         if(!(*pos=manio_tell(manio)))
     267             :         {
     268           0 :                 logp("Could not manio_tell first pos in %s(): %s\n",
     269           0 :                         __func__, strerror(errno));
     270           0 :                 goto error;
     271             :         }
     272             : 
     273             :         while(1)
     274             :         {
     275       12690 :                 if(sb->path.buf && !got_vss_start)
     276             :                 {
     277        8270 :                         iobuf_free_content(&lastpath);
     278        8270 :                         iobuf_move(&lastpath, &sb->path);
     279        8270 :                         if(!sbuf_is_filedata(sb)
     280         114 :                           && !sbuf_is_vssdata(sb))
     281             :                         {
     282         104 :                                 iobuf_free_content(result);
     283         104 :                                 iobuf_move(result, &lastpath);
     284             : 
     285         104 :                                 man_off_t_free(pos);
     286         104 :                                 if(!(*pos=manio_tell(manio)))
     287             :                                 {
     288           0 :                                         logp("Could not manio_tell pos in %s(): %s\n",
     289           0 :                                                 __func__, strerror(errno));
     290           0 :                                         goto error;
     291             :                                 }
     292             :                         }
     293             :                 }
     294       12690 :                 if(sb->endfile.buf && !got_vss_start)
     295             :                 {
     296        8152 :                         iobuf_free_content(result);
     297        8152 :                         iobuf_move(result, &lastpath);
     298             : 
     299        8152 :                         man_off_t_free(pos);
     300        8152 :                         if(!(*pos=manio_tell(manio)))
     301             :                         {
     302           0 :                                 logp("Could not manio_tell pos in %s(): %s\n",
     303           0 :                                         __func__, strerror(errno));
     304           0 :                                 goto error;
     305             :                         }
     306             :                 }
     307             : 
     308       12690 :                 sbuf_free_content(sb);
     309       12690 :                 ars=manio_read(manio, sb);
     310       12690 :                 if(dpth && set_higher_datapth(sb, dpth)) goto error;
     311             : 
     312       12690 :                 switch(ars)
     313             :                 {
     314             :                         case 0: break;
     315         169 :                         case 1: iobuf_free_content(&lastpath);
     316         169 :                                 sbuf_free(&sb);
     317         169 :                                 return 0;
     318             :                         default:
     319          39 :                                 if(result->buf)
     320          32 :                                         logp("Error after %s in %s()\n",
     321             :                                                 iobuf_to_printable(result),
     322             :                                                 __func__);
     323             :                                 // Treat error in changed manio as
     324             :                                 // OK - could have been a short write.
     325          39 :                                 iobuf_free_content(&lastpath);
     326          39 :                                 sbuf_free(&sb);
     327          39 :                                 return 0;
     328             :                 }
     329             : 
     330             :                 // Some hacks for split_vss.
     331       12482 :                 switch(sb->path.cmd)
     332             :                 {
     333             :                         case CMD_VSS:
     334             :                         case CMD_ENC_VSS:
     335             :                                 got_vss_start=1;
     336             :                                 break;
     337             :                         case CMD_VSS_T:
     338             :                         case CMD_ENC_VSS_T:
     339             :                                 got_vss_start=0;
     340             :                                 break;
     341             :                         case CMD_FILE:
     342             :                         case CMD_ENC_FILE:
     343        8154 :                                 if(S_ISDIR(sb->statp.st_mode))
     344          48 :                                         got_vss_start=0;
     345             :                                 break;
     346             :                         default:
     347             :                                 break;
     348             :                 }
     349             : 
     350       12482 :                 if(cntr)
     351             :                 {
     352           0 :                         if(sb->endfile.buf)
     353             :                         {
     354           0 :                                 uint64_t e=strtoull(sb->endfile.buf, NULL, 10);
     355           0 :                                 cntr_add_bytes(cntr, e);
     356             :                         }
     357             :                 }
     358             :         }
     359             : 
     360             : error:
     361           0 :         iobuf_free_content(&lastpath);
     362           0 :         sbuf_free(&sb);
     363           0 :         man_off_t_free(pos);
     364           0 :         return -1;
     365             : }
     366             : 
     367           0 : static int add_to_cntr(
     368             :         struct cntr *cntr,
     369             :         enum cmd cmd,
     370             :         enum cntr_manio cntr_manio
     371             : ) {
     372           0 :         switch(cntr_manio)
     373             :         {
     374             :                 case CNTR_MANIO_NEW:
     375           0 :                         cntr_add(cntr, cmd, 0);
     376           0 :                         break;
     377             :                 case CNTR_MANIO_CHANGED:
     378           0 :                         cntr_add_changed(cntr, cmd);
     379           0 :                         break;
     380             :                 case CNTR_MANIO_SAME:
     381           0 :                         cntr_add_same(cntr, cmd);
     382           0 :                         break;
     383             :                 case CNTR_MANIO_DELETED:
     384           0 :                         cntr_add_deleted(cntr, cmd);
     385           0 :                         break;
     386             :                 default:
     387           0 :                         logp("Unknown counter in %s(): %c\n",
     388             :                                 __func__, cntr_manio);
     389           0 :                         return -1;
     390             :         }
     391             :         return 0;
     392             : }
     393             : 
     394           0 : static int forward_past_entry_counter(
     395             :         struct manio *manio,
     396             :         struct iobuf *target,
     397             :         struct cntr *cntr,
     398             :         man_off_t **pos
     399             : ) {
     400             :         char what[1];
     401             :         struct iobuf rbuf;
     402             : 
     403           0 :         iobuf_init(&rbuf);
     404             : 
     405             :         while(1)
     406             :         {
     407           0 :                 iobuf_free_content(&rbuf);
     408           0 :                 man_off_t_free(pos);
     409           0 :                 if(!(*pos=manio_tell(manio)))
     410             :                 {
     411           0 :                         logp("Could not manio_tell top pos in %s(): %s\n",
     412           0 :                                 __func__, strerror(errno));
     413           0 :                         goto error;
     414             :                 }
     415             : 
     416           0 :                 switch(fzp_read_ensure(manio->fzp, what, sizeof(what), __func__))
     417             :                 {
     418             :                         case 0: break;
     419             :                         case 1: return 0;
     420             :                         default:
     421           0 :                                 logp("Error read in %s(), but continuing\n",
     422             :                                         __func__);
     423             :                                 // Treat error in unchanged manio as
     424             :                                 // OK - could have been a short write.
     425           0 :                                 iobuf_free_content(&rbuf);
     426           0 :                                 return 0;
     427             :                 }
     428             : 
     429           0 :                 switch(iobuf_fill_from_fzp(&rbuf, manio->fzp))
     430             :                 {
     431             :                         case 0: break;
     432             :                         case 1:
     433           0 :                                 iobuf_free_content(&rbuf);
     434           0 :                                 return 0;
     435             :                         default:
     436           0 :                                 logp("Error in %s(), but continuing\n",
     437             :                                         __func__);
     438             :                                 // Treat error in unchanged manio as
     439             :                                 // OK - could have been a short write.
     440           0 :                                 iobuf_free_content(&rbuf);
     441           0 :                                 return 0;
     442             :                 }
     443             : 
     444           0 :                 switch(iobuf_pathcmp(target, &rbuf))
     445             :                 {
     446             :                         case 0:
     447           0 :                                 add_to_cntr(cntr, rbuf.cmd, what[0]);
     448             :                                 // Exact match, we want to be past here.
     449           0 :                                 man_off_t_free(pos);
     450           0 :                                 if(!(*pos=manio_tell(manio)))
     451             :                                 {
     452           0 :                                         logp("Could not manio_tell pos in %s(): "
     453           0 :                                                 "%s\n", __func__, strerror(errno));
     454           0 :                                         goto error;
     455             :                                 }
     456           0 :                                 iobuf_free_content(&rbuf);
     457           0 :                                 return 0;
     458             :                         case -1:
     459             :                                 // Gone past the match, we want to return to
     460             :                                 // the previous tell. Do not add_to_cntr,
     461             :                                 // or we will have one too many.
     462           0 :                                 iobuf_free_content(&rbuf);
     463           0 :                                 return 0;
     464             :                         default:
     465             :                                 // Not gone far enough yet, continue.
     466           0 :                                 add_to_cntr(cntr, rbuf.cmd, what[0]);
     467             :                                 break;
     468             :                 }
     469             :         }
     470             : 
     471             : error:
     472           0 :         iobuf_free_content(&rbuf);
     473           0 :         man_off_t_free(pos);
     474           0 :         return -1;
     475             : }
     476             : 
     477           0 : static int tell_and_truncate(struct manio **manio, int compression)
     478             : {
     479           0 :         int ret=-1;
     480           0 :         man_off_t *pos=NULL;
     481           0 :         if(!(pos=manio_tell(*manio))) {
     482           0 :                 logp("Could not get pos in %s\n", __func__);
     483           0 :                 goto end;
     484             :         }
     485           0 :         if(manio_close_and_truncate(manio, pos, compression))
     486             :                 goto end;
     487           0 :         ret=0;
     488             : end:
     489           0 :         man_off_t_free(&pos);
     490           0 :         return ret;
     491             : }
     492             : 
     493             : // Return p1manio position.
     494           0 : static int do_resume_work(
     495             :         man_off_t **pos_phase1,
     496             :         man_off_t **pos_current,
     497             :         struct sdirs *sdirs,
     498             :         struct dpth *dpth, struct conf **cconfs
     499             : ) {
     500           0 :         int ret=-1;
     501           0 :         man_off_t *pos=NULL;
     502           0 :         struct iobuf *chb=NULL;
     503           0 :         struct manio *cmanio=NULL;
     504           0 :         struct manio *chmanio=NULL;
     505           0 :         struct manio *unmanio=NULL;
     506           0 :         struct manio *p1manio=NULL;
     507           0 :         struct manio *counters_d=NULL;
     508           0 :         struct manio *counters_n=NULL;
     509           0 :         enum protocol protocol=get_protocol(cconfs);
     510           0 :         struct cntr *cntr=get_cntr(cconfs);
     511           0 :         int compression=get_int(cconfs[OPT_COMPRESSION]);
     512             : 
     513           0 :         if(!(cmanio=manio_open(sdirs->cmanifest,
     514             :                 MANIO_MODE_READ, protocol))
     515           0 :           || !(p1manio=manio_open_phase1(sdirs->phase1data,
     516             :                 MANIO_MODE_READ, protocol))
     517           0 :           || !(chmanio=manio_open_phase2(sdirs->changed,
     518             :                 MANIO_MODE_READ, protocol))
     519           0 :           || !(unmanio=manio_open_phase2(sdirs->unchanged,
     520             :                 MANIO_MODE_READ, protocol))
     521             :         // The counters are always flat files, which is given by PROTO_1.
     522           0 :           || !(counters_d=manio_open_phase2(sdirs->counters_d,
     523             :                 MANIO_MODE_READ, PROTO_1))
     524           0 :           || !(counters_n=manio_open_phase2(sdirs->counters_n,
     525             :                 MANIO_MODE_READ, PROTO_1)))
     526             :                         goto end;
     527             : 
     528           0 :         if(!(chb=iobuf_alloc()))
     529             :                 goto error;
     530             : 
     531           0 :         logp("Setting up resume positions...\n");
     532             : 
     533           0 :         if(get_last_good_entry(chmanio, chb, cntr, dpth, protocol, &pos)
     534           0 :           || manio_close_and_truncate(&chmanio, pos, compression))
     535             :                 goto error;
     536             : 
     537           0 :         man_off_t_free(&pos);
     538             : 
     539           0 :         if(chb->buf)
     540             :         {
     541           0 :                 logp("  last good entry:    %s\n",
     542             :                         iobuf_to_printable(chb));
     543             :                 // Now need to go to the appropriate places in p1manio, cmanio
     544             :                 // and unmanio.
     545             : 
     546           0 :                 logp("  setting pos_phase1\n");
     547           0 :                 if(forward_past_entry(p1manio, chb, protocol, pos_phase1))
     548             :                         goto error;
     549             : 
     550             :                 // This sets pos_current. This manifest may not exist.
     551           0 :                 if(cmanio->fzp)
     552             :                 {
     553           0 :                         logp("  setting pos_current\n");
     554           0 :                         if (forward_past_entry(cmanio,
     555             :                                 chb, protocol, pos_current))
     556             :                                         goto error;
     557             :                 }
     558             : 
     559             :                 // The unchanged manio needs to be positioned just before the
     560             :                 // found entry, otherwise it ends up having a duplicated entry.
     561           0 :                 if(forward_before_entry(unmanio,
     562             :                         chb, cntr, dpth, protocol, &pos))
     563             :                                 goto error;
     564           0 :                 if(manio_close_and_truncate(&unmanio, pos, compression))
     565             :                         goto error;
     566           0 :                 man_off_t_free(&pos);
     567             : 
     568           0 :                 logp("  setting entry counter_d\n");
     569           0 :                 if(forward_past_entry_counter(counters_d, chb, cntr, &pos))
     570             :                                 goto error;
     571           0 :                 if(manio_close_and_truncate(&counters_d, pos, 0))
     572             :                         goto error;
     573           0 :                 man_off_t_free(&pos);
     574             : 
     575           0 :                 logp("  setting entry counter_n\n");
     576           0 :                 if(forward_past_entry_counter(counters_n, chb, cntr, &pos))
     577             :                                 goto error;
     578           0 :                 if(manio_close_and_truncate(&counters_n, pos, 0))
     579             :                         goto error;
     580           0 :                 man_off_t_free(&pos);
     581             :         }
     582             :         else
     583             :         {
     584           0 :                 logp("  nothing previously transferred\n");
     585           0 :                 if(!(*pos_phase1=manio_tell(p1manio))) {
     586           0 :                         logp("Could not get pos_phase1 in %s\n", __func__);
     587           0 :                         goto error;
     588             :                 }
     589           0 :                 if(tell_and_truncate(&unmanio, compression)
     590           0 :                  || tell_and_truncate(&counters_d, 0)
     591           0 :                  || tell_and_truncate(&counters_n, 0))
     592             :                         goto error;
     593             :         }
     594             : 
     595             :         // Now should have all manios truncated correctly, with pos_phase1 and
     596             :         // pos_current set correctly in order to resume.
     597             :         ret=0;
     598             :         goto end;
     599             : error:
     600           0 :         man_off_t_free(pos_phase1);
     601           0 :         man_off_t_free(pos_current);
     602             : end:
     603           0 :         iobuf_free(&chb);
     604           0 :         man_off_t_free(&pos);
     605           0 :         manio_close(&p1manio);
     606           0 :         manio_close(&cmanio);
     607           0 :         manio_close(&chmanio);
     608           0 :         manio_close(&unmanio);
     609           0 :         manio_close(&counters_d);
     610           0 :         manio_close(&counters_n);
     611           0 :         return ret;
     612             : }
     613             : 
     614           0 : int do_resume(
     615             :         man_off_t **pos_phase1,
     616             :         man_off_t **pos_current,
     617             :         struct sdirs *sdirs,
     618             :         struct dpth *dpth,
     619             :         struct conf **cconfs
     620             : ) {
     621           0 :         int ret=-1;
     622           0 :         struct manio *chmanio=NULL;
     623           0 :         struct manio *unmanio=NULL;
     624           0 :         struct manio *p1manio=NULL;
     625           0 :         struct manio *counters_d=NULL;
     626           0 :         struct manio *counters_n=NULL;
     627           0 :         enum protocol protocol=get_protocol(cconfs);
     628             : 
     629           0 :         logp("Begin phase1 (read previous file system scan)\n");
     630           0 :         if(!(p1manio=manio_open_phase1(sdirs->phase1data, "rb", protocol))
     631           0 :           || read_phase1(p1manio, cconfs))
     632             :                 goto end;
     633           0 :         manio_close(&p1manio);
     634             : 
     635             :         // First, open them in append mode, so that they will be created if
     636             :         // they do not exist.
     637           0 :         if(!(chmanio=manio_open_phase2(sdirs->changed, "ab", protocol))
     638           0 :           || !(unmanio=manio_open_phase2(sdirs->unchanged, "ab", protocol))
     639           0 :           || !(counters_d=manio_open_phase2(sdirs->counters_d, "ab", PROTO_1))
     640           0 :           || !(counters_n=manio_open_phase2(sdirs->counters_n, "ab", PROTO_1)))
     641             :                 goto end;
     642           0 :         manio_close(&chmanio);
     643           0 :         manio_close(&unmanio);
     644           0 :         manio_close(&counters_d);
     645           0 :         manio_close(&counters_n);
     646             : 
     647           0 :         if(do_resume_work(pos_phase1, pos_current, sdirs, dpth, cconfs))
     648             :                 goto end;
     649             : 
     650           0 :         if(dpth_incr(dpth)) goto end;
     651             : 
     652           0 :         logp("End phase1 (read previous file system scan)\n");
     653           0 :         ret=0;
     654             : end:
     655           0 :         manio_close(&p1manio);
     656           0 :         manio_close(&chmanio);
     657           0 :         manio_close(&unmanio);
     658           0 :         manio_close(&counters_d);
     659           0 :         manio_close(&counters_n);
     660           0 :         return ret;
     661             : }

Generated by: LCOV version 1.13