Line data    Source code

       1             : #include "../../burp.h"
       2             : #include "../../alloc.h"
       3             : #include "../../cmd.h"
       4             : #include "../../fzp.h"
       5             : #include "../../hexmap.h"
       6             : #include "../../iobuf.h"
       7             : #include "../../log.h"
       8             : #include "../../protocol2/blk.h"
       9             : 
      10             : // For retrieving stored data.
      11             : struct rblk
      12             : {
      13             :         char *datpath;
      14             :         struct iobuf readbuf[DATA_FILE_SIG_MAX];
      15             :         uint16_t readbuflen;
      16             : };
      17             : 
      18             : #define RBLK_MAX        10
      19             : 
      20           0 : static int load_rblk(struct rblk *rblks, int ind, const char *datpath)
      21             : {
      22             :         int r;
      23           0 :         int ret=-1;
      24           0 :         int done=0;
      25             :         struct fzp *fzp;
      26             :         struct iobuf rbuf;
      27             : 
      28           0 :         iobuf_init(&rbuf);
      29             : 
      30           0 :         free_w(&rblks[ind].datpath);
      31           0 :         if(!(rblks[ind].datpath=strdup_w(datpath, __func__)))
      32           0 :                 goto end;
      33             : 
      34           0 :         logp("swap %d to: %s\n", ind, datpath);
      35             : 
      36           0 :         if(!(fzp=fzp_open(datpath, "rb")))
      37           0 :                 goto end;
      38           0 :         for(r=0; r<DATA_FILE_SIG_MAX; r++)
      39             :         {
      40           0 :                 switch(iobuf_fill_from_fzp_data(&rbuf, fzp))
      41             :                 {
      42           0 :                         case 0: if(rbuf.cmd!=CMD_DATA)
      43             :                                 {
      44             :                                         logp("unknown cmd in %s: %c\n",
      45           0 :                                                 __func__, rbuf.cmd);
      46           0 :                                         goto end;
      47             :                                 }
      48           0 :                                 iobuf_free_content(&rblks[ind].readbuf[r]);
      49           0 :                                 iobuf_move(&rblks[ind].readbuf[r], &rbuf);
      50           0 :                                 continue;
      51           0 :                         case 1: done++;
      52           0 :                                 break;
      53           0 :                         default: goto end;
      54             :                 }
      55           0 :                 if(done) break;
      56             :         }
      57           0 :         rblks[ind].readbuflen=r;
      58           0 :         ret=0;
      59             : end:
      60           0 :         fzp_close(&fzp);
      61           0 :         return ret;
      62             : }
      63             : 
      64           0 : static struct rblk *get_rblk(struct rblk *rblks, const char *datpath)
      65             : {
      66             :         static int current_ind=0;
      67             :         static int last_swap_ind=0;
      68           0 :         int ind=current_ind;
      69             : 
      70             :         while(1)
      71             :         {
      72           0 :                 if(!rblks[ind].datpath)
      73             :                 {
      74           0 :                         if(load_rblk(rblks, ind, datpath)) return NULL;
      75           0 :                         last_swap_ind=ind;
      76           0 :                         current_ind=ind;
      77           0 :                         return &rblks[current_ind];
      78             :                 }
      79           0 :                 else if(!strcmp(rblks[ind].datpath, datpath))
      80             :                 {
      81           0 :                         current_ind=ind;
      82           0 :                         return &rblks[current_ind];
      83             :                 }
      84           0 :                 ind++;
      85           0 :                 if(ind==RBLK_MAX) ind=0;
      86           0 :                 if(ind==current_ind)
      87             :                 {
      88             :                         // Went through all RBLK_MAX entries.
      89             :                         // Replace the oldest one.
      90           0 :                         ind=last_swap_ind+1;
      91           0 :                         if(ind==RBLK_MAX) ind=0;
      92           0 :                         if(load_rblk(rblks, ind, datpath)) return NULL;
      93           0 :                         last_swap_ind=ind;
      94           0 :                         current_ind=ind;
      95           0 :                         return &rblks[current_ind];
      96             :                 }
      97           0 :         }
      98             : }
      99             : 
     100           0 : int rblk_retrieve_data(const char *datpath, struct blk *blk)
     101             : {
     102             :         static char fulldatpath[256]="";
     103             :         static struct rblk *rblks=NULL;
     104             :         uint16_t datno;
     105             :         struct rblk *rblk;
     106             : 
     107             :         snprintf(fulldatpath, sizeof(fulldatpath), "%s/%s", datpath,
     108           0 :                 uint64_to_savepathstr_with_sig_uint(blk->savepath, &datno));
     109             : 
     110           0 :         if(!rblks
     111           0 :           && !(rblks=(struct rblk *)
     112           0 :                 calloc_w(RBLK_MAX, sizeof(struct rblk), __func__)))
     113           0 :                         return -1;
     114             : 
     115           0 :         if(!(rblk=get_rblk(rblks, fulldatpath)))
     116             :         {
     117           0 :                 return -1;
     118             :         }
     119             : 
     120             : //      printf("lookup: %s (%s)\n", fulldatpath, cp);
     121           0 :         if(datno>rblk->readbuflen)
     122             :         {
     123             :                 logp("dat index %d is greater than readbuflen: %d\n",
     124           0 :                         datno, rblk->readbuflen);
     125           0 :                 return -1;
     126             :         }
     127           0 :         blk->data=rblk->readbuf[datno].buf;
     128           0 :         blk->length=rblk->readbuf[datno].len;
     129             : //      printf("length: %d\n", blk->length);
     130             : 
     131           0 :         return 0;
     132             : }