Line data    Source code

       1             : #include "../../burp.h"
       2             : #include "../../alloc.h"
       3             : #include "../../cntr.h"
       4             : #include "../../conf.h"
       5             : #include "../../fsops.h"
       6             : #include "../../fzp.h"
       7             : #include "../../log.h"
       8             : #include "../../prepend.h"
       9             : #include "../child.h"
      10             : #include "link.h"
      11             : 
      12           0 : int recursive_hardlink(const char *src, const char *dst, struct conf **confs)
      13             : {
      14           0 :         int ret=-1;
      15           0 :         DIR *dirp=NULL;
      16           0 :         char *tmp=NULL;
      17           0 :         char *fullpatha=NULL;
      18           0 :         char *fullpathb=NULL;
      19           0 :         struct dirent *entry=NULL;
      20           0 :         struct cntr *cntr=get_cntr(confs);
      21             : 
      22           0 :         if(!(tmp=prepend_s(dst, "dummy")))
      23             :                 goto end;
      24           0 :         if(mkpath(&tmp, dst))
      25             :         {
      26           0 :                 logp("could not mkpath for %s\n", tmp);
      27           0 :                 goto end;
      28             :         }
      29             : 
      30           0 :         if(!(dirp=opendir(src)))
      31             :         {
      32           0 :                 logp("opendir %s in %s: %s\n",
      33           0 :                         src, __func__, strerror(errno));
      34           0 :                 goto end;
      35             :         }
      36             : 
      37             :         while(1)
      38             :         {
      39             :                 struct stat statp;
      40             : 
      41           0 :                 errno=0;
      42           0 :                 if(!(entry=readdir(dirp)))
      43             :                 {
      44           0 :                         if(errno)
      45             :                         {
      46           0 :                                 logp("error in readdir in %s: %s\n",
      47             :                                         __func__, strerror(errno));
      48           0 :                                 goto end;
      49             :                         }
      50           0 :                         break;
      51             :                 }
      52             : 
      53           0 :                 if(!filter_dot(entry))
      54           0 :                         continue;
      55             : 
      56           0 :                 free_w(&fullpatha);
      57           0 :                 free_w(&fullpathb);
      58           0 :                 if(!(fullpatha=prepend_s(src, entry->d_name))
      59           0 :                   || !(fullpathb=prepend_s(dst, entry->d_name)))
      60             :                         goto end;
      61             : 
      62             : #ifdef _DIRENT_HAVE_D_TYPE
      63             : // Faster evaluation on most systems.
      64           0 :                 if(entry->d_type==DT_DIR)
      65             :                 {
      66           0 :                         if(recursive_hardlink(fullpatha, fullpathb, confs))
      67             :                                 goto end;
      68             :                 }
      69             :                 else
      70             : #endif
      71             :                 // Otherwise, we have to do an lstat() anyway, because we
      72             :                 // will need to check the number of hardlinks in do_link().
      73           0 :                 if(lstat(fullpatha, &statp))
      74             :                 {
      75           0 :                         logp("could not lstat %s\n", fullpatha);
      76             :                 }
      77           0 :                 else if(S_ISDIR(statp.st_mode))
      78             :                 {
      79           0 :                         if(recursive_hardlink(fullpatha, fullpathb, confs))
      80             :                                 goto end;
      81             :                 }
      82             :                 else
      83             :                 {
      84             :                         //logp("hardlinking %s to %s\n", fullpathb, fullpatha);
      85           0 :                         if(write_status(CNTR_STATUS_SHUFFLING,
      86             :                                 fullpathb, cntr)
      87           0 :                           || do_link(fullpatha, fullpathb, &statp, confs,
      88             :                                 0 /* do not overwrite target */))
      89             :                                         goto end;
      90             :                 }
      91             :         }
      92             : 
      93           0 :         ret=0;
      94             : end:
      95           0 :         if(dirp) closedir(dirp);
      96           0 :         free_w(&fullpatha);
      97           0 :         free_w(&fullpathb);
      98           0 :         free_w(&tmp);
      99             : 
     100           0 :         return ret;
     101             : }
     102             : 
     103             : #define DUP_CHUNK       4096
     104           0 : static int duplicate_file(const char *oldpath, const char *newpath)
     105             : {
     106           0 :         int ret=-1;
     107           0 :         size_t s=0;
     108           0 :         size_t t=0;
     109           0 :         struct fzp *op=NULL;
     110           0 :         struct fzp *np=NULL;
     111           0 :         char buf[DUP_CHUNK]="";
     112           0 :         if(!(op=fzp_open(oldpath, "rb"))
     113           0 :           || !(np=fzp_open(newpath, "wb")))
     114             :                 goto end;
     115             : 
     116           0 :         while((s=fzp_read(op, buf, DUP_CHUNK))>0)
     117             :         {
     118           0 :                 t=fzp_write(np, buf, s);
     119           0 :                 if(t!=s)
     120             :                 {
     121           0 :                         logp("could not write all bytes: %lu!=%lu\n",
     122             :                                 (unsigned long)s, (unsigned long)t);
     123           0 :                         goto end;
     124             :                 }
     125             :         }
     126             : 
     127             :         ret=0;
     128             : end:
     129           0 :         fzp_close(&np);
     130           0 :         fzp_close(&op);
     131           0 :         if(ret) logp("could not duplicate %s to %s\n", oldpath, newpath);
     132           0 :         return ret;
     133             : }
     134             : 
     135           9 : int do_link(const char *oldpath, const char *newpath, struct stat *statp,
     136             :         struct conf **confs, uint8_t overwrite)
     137             : {
     138             :         /* Avoid creating too many hardlinks */
     139           9 :         if(confs
     140           6 :           && statp->st_nlink >= (unsigned int)get_int(confs[OPT_MAX_HARDLINKS]))
     141             :         {
     142           0 :                 return duplicate_file(oldpath, newpath);
     143             :         }
     144           9 :         else if(link(oldpath, newpath))
     145             :         {
     146           0 :                 if(overwrite && errno==EEXIST)
     147             :                 {
     148           0 :                         unlink(newpath);
     149           0 :                         if(!link(oldpath, newpath))
     150             :                         {
     151             :                                 //logp("Successful hard link of '%s' to '%s' after unlinking the former\n", newpath, oldpath);
     152             :                                 return 0;
     153             :                         }
     154             :                 }
     155           0 :                 logp("could not hard link '%s' to '%s': %s\n",
     156           0 :                         newpath, oldpath, strerror(errno));
     157           0 :                 return -1;
     158             :         }
     159             :         return 0;
     160             : }