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