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