A few more tweaks.
[rsync-patches.git] / link-by-hash.diff
1 To: rsync@lists.samba.org
2 From: "Jason M. Felice" <jfelice@cronosys.com>
3 Subject: [patch] Add `--link-by-hash' option (rev 5).
4 Date: Mon, 23 Feb 2004 13:29:08 -0500
5
6 This patch adds the --link-by-hash=DIR option, which hard links received
7 files in a link farm arranged by MD4 file hash.  The result is that the system
8 will only store one copy of the unique contents of each file, regardless of
9 the file's name.
10
11 (rev 5)
12 * Fixed silly logic error.
13
14 (rev 4)
15 * Updated for committed robust_rename() patch, other changes in CVS.
16
17 (rev 3)
18 * Don't link empty files.
19 * Roll over to new file when filesystem maximum link count is reached.
20 * If link fails for another reason, leave non-linked file there.
21 * Depends on rsync-rename.diff
22
23 (rev 2)
24 * This revision is actually against CVS HEAD (I didn't realize I was working
25   from a stale rsync'd CVS).
26 * Apply permissions after linking (permissions were lost if we already had
27   a copy of the file in the link farm).
28
29 Patch Summary:
30
31     -1   +1    Makefile.in
32     -0   +351  hashlink.c (new)
33     -1   +22   options.c
34     -0   +6    proto.h
35     -6   +21   receiver.c
36     -2   +8    rsync.c
37     -0   +8    rsync.h
38
39 --- hashlink.c  1969-12-31 19:00:00.000000000 -0500
40 +++ hashlink.c  2004-02-23 10:30:45.000000000 -0500
41 @@ -0,0 +1,351 @@
42 +/*
43 +   Copyright (C) Cronosys, LLC 2004
44 +
45 +   This program is free software; you can redistribute it and/or modify
46 +   it under the terms of the GNU General Public License as published by
47 +   the Free Software Foundation; either version 2 of the License, or
48 +   (at your option) any later version.
49 +
50 +   This program is distributed in the hope that it will be useful,
51 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
52 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
53 +   GNU General Public License for more details.
54 +
55 +   You should have received a copy of the GNU General Public License
56 +   along with this program; if not, write to the Free Software
57 +   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
58 +*/
59 +
60 +/* This file contains code used by the --link-by-hash option. */
61 +
62 +#include "rsync.h"
63 +
64 +extern char *link_by_hash_dir;
65 +
66 +#ifdef HAVE_LINK
67 +
68 +char* make_hash_name(struct file_struct *file)
69 +{
70 +       char hash[33], *dst;
71 +       unsigned char *src;
72 +       unsigned char c;
73 +       int i;
74 +
75 +       src = (unsigned char*)file->u.sum;
76 +       for (dst = hash, i = 0; i < 4; i++, src++) {
77 +               c = *src >> 4;
78 +               *(dst++) = (c >= 10) ? (c - 10 + 'a') : (c + '0');
79 +               c = *src & 0x0f;
80 +               *(dst++) = (c >= 10) ? (c - 10 + 'a') : (c + '0');
81 +       }
82 +       *dst++ = '/';
83 +       for (i = 0; i < 12; i++, src++) {
84 +               c = *src >> 4;
85 +               *(dst++) = (c >= 10) ? (c - 10 + 'a') : (c + '0');
86 +               c = *src & 0x0f;
87 +               *(dst++) = (c >= 10) ? (c - 10 + 'a') : (c + '0');
88 +       }
89 +       *dst = 0;
90 +
91 +       asprintf(&dst,"%s/%s",link_by_hash_dir,hash);
92 +       return dst;
93 +}
94 +
95 +
96 +void kill_hashfile(struct hashfile_struct *hashfile)
97 +{
98 +       if (!hashfile)
99 +               return;
100 +       free(hashfile->name);
101 +       close(hashfile->fd);
102 +       free(hashfile);
103 +}
104 +
105 +
106 +void kill_hashfiles(struct hashfile_struct *hashfiles)
107 +{
108 +       struct hashfile_struct *iter, *next;
109 +       if ((iter = hashfiles) != NULL) {
110 +               do {
111 +                       next = iter->next;
112 +                       kill_hashfile(iter);
113 +                       iter = next;
114 +               } while (iter != hashfiles);
115 +       }
116 +}
117 +
118 +
119 +struct hashfile_struct *find_hashfiles(char *hashname, int64 size, long *fnbr)
120 +{
121 +       DIR *d;
122 +       struct dirent *di;
123 +       struct hashfile_struct *hashfiles = NULL, *hashfile;
124 +       STRUCT_STAT st;
125 +       long this_fnbr;
126 +
127 +       *fnbr = 0;
128 +       
129 +       /* Build a list of potential candidates and open
130 +        * them. */
131 +       if ((d = opendir(hashname)) == NULL) {
132 +               rprintf(FERROR,"opendir \"%s\": %s\n",
133 +                       hashname, strerror(errno));
134 +               free(hashname);
135 +               return NULL;
136 +       }
137 +       while ((di = readdir(d)) != NULL) {
138 +               if (!strcmp(di->d_name,".") || !strcmp(di->d_name,"..")) {
139 +                       continue;
140 +               }
141 +
142 +               /* We need to have the largest fnbr in case we need to store
143 +                * a new file. */
144 +               this_fnbr = atol(di->d_name);
145 +               if (this_fnbr > *fnbr)
146 +                       *fnbr = this_fnbr;
147 +
148 +               hashfile = (struct hashfile_struct*)malloc(sizeof(struct hashfile_struct));
149 +               asprintf(&hashfile->name,"%s/%s",hashname,
150 +                        di->d_name);
151 +               if (do_stat(hashfile->name,&st) == -1) {
152 +                       rprintf(FERROR,"%s: %s", hashfile->name,
153 +                               strerror(errno));
154 +                       kill_hashfile(hashfile);
155 +                       continue;
156 +               }
157 +               if (st.st_size != size) {
158 +                       kill_hashfile(hashfile);
159 +                       continue;
160 +               }
161 +               hashfile->nlink = st.st_nlink;
162 +               hashfile->fd = open(hashfile->name,O_RDONLY|O_BINARY);
163 +               if (hashfile->fd == -1) {
164 +                       rprintf(FERROR,"%s: %s\n", hashfile->name,
165 +                               strerror(errno));
166 +                       kill_hashfile(hashfile);
167 +                       continue;
168 +               }
169 +               if (hashfiles == NULL)
170 +                       hashfiles = hashfile->next = hashfile->prev = hashfile;
171 +               else {
172 +                       hashfile->next = hashfiles;
173 +                       hashfile->prev = hashfiles->prev;
174 +                       hashfile->next->prev = hashfile;
175 +                       hashfile->prev->next = hashfile;
176 +               }
177 +       }
178 +       closedir(d);
179 +
180 +       return hashfiles;
181 +}
182 +
183 +
184 +struct hashfile_struct *compare_hashfiles(int fd,struct hashfile_struct *files)
185 +{
186 +       int amt, hamt;
187 +       char buffer[BUFSIZ], cmpbuffer[BUFSIZ];
188 +       struct hashfile_struct *iter, *next, *best;
189 +       uint32 nlink;
190 +
191 +       if (!files)
192 +               return NULL;
193 +
194 +       iter = files; /* in case files are 0 bytes */
195 +       while ((amt = read(fd, buffer, BUFSIZ)) > 0) {
196 +               iter = files;
197 +               do {
198 +                       /* Icky bit to resync when we steal the first node. */
199 +                       if (!files)
200 +                               files = iter;
201 +
202 +                       next = iter->next;
203 +
204 +                       hamt = read(iter->fd, cmpbuffer, BUFSIZ);
205 +                       if (amt != hamt || memcmp(buffer, cmpbuffer, amt)) {
206 +                               if (iter == files) {
207 +                                       files = files->prev;
208 +                               }
209 +                               if (iter->next == iter) {
210 +                                       files = next = NULL;
211 +                               } else {
212 +                                       next = iter->next;
213 +                                       if (iter == files) {
214 +                                               /* So we know to resync */
215 +                                               files = NULL;
216 +                                       }
217 +                               }
218 +                               iter->next->prev = iter->prev;
219 +                               iter->prev->next = iter->next;
220 +                               kill_hashfile(iter);
221 +                       }
222 +
223 +                       iter = next;
224 +               } while (iter != files);
225 +
226 +               if (iter == NULL && files == NULL) {
227 +                       /* There are no matches. */
228 +                       return NULL;
229 +               }
230 +               
231 +       }
232 +
233 +       if (amt == -1) {
234 +               rprintf(FERROR,"%s",strerror(errno));
235 +               kill_hashfiles(files);
236 +               return NULL;
237 +       }
238 +
239 +       /* If we only have one file left, use it. */
240 +       if (files == files->next) {
241 +               return files;
242 +       }
243 +
244 +       /* All files which remain in the list are identical and should have
245 +        * the same size.  We pick the one with the lowest link count (we
246 +        * may have rolled over because we hit the maximum link count for
247 +        * the filesystem). */
248 +       best = iter = files;
249 +       nlink = iter->nlink;
250 +       do {
251 +               if (iter->nlink < nlink) {
252 +                       nlink = iter->nlink;
253 +                       best = iter;
254 +               }
255 +               iter = iter->next;
256 +       } while (iter != files);
257 +
258 +       best->next->prev = best->prev;
259 +       best->prev->next = best->next;
260 +       if (files == best)
261 +               files = files->next;
262 +       kill_hashfiles(files);
263 +       return best;
264 +}
265 +
266 +
267 +int link_by_hash(char *fnametmp,char *fname,struct file_struct *file)
268 +{
269 +       STRUCT_STAT st;
270 +       char *hashname = make_hash_name(file);          
271 +       int first = 0, rc;
272 +       char *linkname;
273 +       long last_fnbr;
274 +
275 +       if (file->length == 0) {
276 +               return robust_rename(fnametmp,fname,0644);
277 +       }
278 +
279 +       if (do_stat(hashname, &st) == -1) {
280 +               char *dirname;
281 +
282 +               /* Directory does not exist. */
283 +               dirname = strdup(hashname);
284 +               *strrchr(dirname,'/') = 0;
285 +               if (do_mkdir(dirname, 0755) == -1 && errno != EEXIST) {
286 +                       rprintf(FERROR, "mkdir %s: %s\n", dirname,
287 +                               strerror(errno));
288 +                       free(hashname);
289 +                       free(dirname);
290 +                       return robust_rename(fnametmp,fname,0644);
291 +               }
292 +               free(dirname);
293 +
294 +               if (do_mkdir(hashname, 0755) == -1 && errno != EEXIST) {
295 +                       rprintf(FERROR, "mkdir %s: %s\n", hashname,
296 +                               strerror(errno));
297 +                       free(hashname);
298 +                       return robust_rename(fnametmp,fname,0644);
299 +               }
300 +
301 +               first = 1;
302 +               asprintf(&linkname,"%s/0",hashname);
303 +               rprintf(FINFO, "(1) linkname = %s\n", linkname);
304 +                       
305 +       } else {
306 +               struct hashfile_struct *hashfiles, *hashfile;
307 +               int fd;
308 +
309 +               if (do_stat(fnametmp,&st) == -1) {
310 +                       rprintf(FERROR,"%s: %s\n",fname,strerror(errno));
311 +                       return -1;
312 +               }
313 +               hashfiles = find_hashfiles(hashname, st.st_size, &last_fnbr);
314 +
315 +               if (hashfiles == NULL) {
316 +                       first = 1;
317 +                       asprintf(&linkname,"%s/0",hashname);
318 +                       rprintf(FINFO, "(2) linkname = %s\n", linkname);
319 +               } else {
320 +                       
321 +                       /* Search for one identical to us. */
322 +                       if ((fd = open(fnametmp,O_RDONLY|O_BINARY)) == -1) {
323 +                               rprintf(FERROR,"%s: %s\n",fnametmp,
324 +                                       strerror(errno));
325 +                               kill_hashfiles(hashfiles);
326 +                               return -1;
327 +                       }
328 +                       hashfile = compare_hashfiles(fd, hashfiles);
329 +                       hashfiles = NULL;
330 +
331 +                       if (hashfile) {
332 +                               first = 0;
333 +                               linkname = strdup(hashfile->name);
334 +                               rprintf(FINFO, "(3) linkname = %s\n", linkname);
335 +                               kill_hashfile(hashfile);
336 +                       } else {
337 +                               first = 1;
338 +                               asprintf(&linkname, "%s/%ld", hashname,
339 +                                        last_fnbr + 1);
340 +                               rprintf(FINFO, "(4) linkname = %s\n", linkname);
341 +                       }
342 +               }
343 +       }
344 +
345 +       if (!first) {
346 +               rprintf(FINFO, "link-by-hash (existing): \"%s\" -> %s\n",
347 +                               linkname, full_fname(fname));
348 +               rc = do_link(linkname, fname);
349 +               if (rc == -1) {
350 +                       if (errno == EMLINK) {
351 +                               first = 1;
352 +                               free(linkname);
353 +                               asprintf(&linkname,"%s/%ld",hashname,
354 +                                        last_fnbr + 1);
355 +                               rprintf(FINFO, "(5) linkname = %s\n", linkname);
356 +                               rprintf(FINFO,"link-by-hash: max link count exceeded, starting new file \"%s\".\n", linkname);
357 +                       } else {
358 +                               rprintf(FERROR,"link \"%s\" -> %s: %s\n",
359 +                                       linkname,full_fname(fname),
360 +                                       strerror(errno));
361 +                               robust_unlink(fname);
362 +                               rc = robust_rename(fnametmp,fname,0644);
363 +                       }
364 +               } else {
365 +                       do_unlink(fnametmp);
366 +               }
367 +       }
368 +
369 +       if (first) {
370 +               rprintf(FINFO, "link-by-hash (new): %s -> \"%s\"\n",
371 +                               full_fname(fname),linkname);
372 +
373 +               rc = robust_rename(fnametmp,fname,0644);
374 +               if (rc != 0) {
375 +                       rprintf(FERROR,"rename \"%s\" -> \"%s\": %s\n",
376 +                               full_fname(fnametmp),full_fname(fname),
377 +                               strerror(errno));
378 +               }
379 +               rc = do_link(fname,linkname);
380 +               if (rc != 0) {
381 +                       rprintf(FERROR,"link \"%s\" -> \"%s\": %s\n",
382 +                               full_fname(fname),linkname,
383 +                               strerror(errno));
384 +               }
385 +       }
386 +
387 +       free(linkname);
388 +       free(hashname);
389 +       return rc;
390 +}
391 +
392 +#endif
393 --- Makefile.in 2004-02-23 10:22:51.000000000 -0500
394 +++ Makefile.in 2004-02-23 10:22:51.000000000 -0500
395 @@ -35,7 +35,7 @@
396         main.o checksum.o match.o syscall.o log.o backup.o
397  OBJS2=options.o flist.o io.o compat.o hlink.o token.o uidlist.o socket.o \
398         fileio.o batch.o clientname.o
399 -OBJS3=progress.o pipe.o
400 +OBJS3=progress.o pipe.o hashlink.o
401  DAEMON_OBJ = params.o loadparm.o clientserver.o access.o connection.o authenticate.o
402  popt_OBJS=popt/findme.o  popt/popt.o  popt/poptconfig.o \
403         popt/popthelp.o popt/poptparse.o
404 --- options.c   2004-02-23 10:22:51.000000000 -0500
405 +++ options.c   2004-02-23 10:29:14.000000000 -0500
406 @@ -119,6 +119,7 @@
407  char *password_file = NULL;
408  char *rsync_path = RSYNC_PATH;
409  char *backup_dir = NULL;
410 +char *link_by_hash_dir = NULL;
411  char backup_dir_buf[MAXPATHLEN];
412  int rsync_port = RSYNC_PORT;
413  int link_dest = 0;
414 @@ -264,6 +265,7 @@
415    rprintf(F," -T  --temp-dir=DIR          create temporary files in directory DIR\n");
416    rprintf(F,"     --compare-dest=DIR      also compare destination files relative to DIR\n");
417    rprintf(F,"     --link-dest=DIR         create hardlinks to DIR for unchanged files\n");
418 +  rprintf(F,"     --link-by-hash=DIR      create hardlinks by hash to DIR for regular files\n");
419    rprintf(F," -P                          equivalent to --partial --progress\n");
420    rprintf(F," -z, --compress              compress file data\n");
421    rprintf(F," -C, --cvs-exclude           auto ignore files in the same way CVS does\n");
422 @@ -303,7 +305,7 @@
423  enum {OPT_VERSION = 1000, OPT_SENDER, OPT_EXCLUDE, OPT_EXCLUDE_FROM,
424        OPT_DELETE_AFTER, OPT_DELETE_EXCLUDED, OPT_LINK_DEST,
425        OPT_INCLUDE, OPT_INCLUDE_FROM, OPT_MODIFY_WINDOW,
426 -      OPT_READ_BATCH, OPT_WRITE_BATCH,
427 +      OPT_READ_BATCH, OPT_WRITE_BATCH, OPT_LINK_BY_HASH,
428        OPT_REFUSED_BASE = 9000};
429  
430  static struct poptOption long_options[] = {
431 @@ -360,6 +362,7 @@
432    {"temp-dir",        'T', POPT_ARG_STRING, &tmpdir, 0, 0, 0 },
433    {"compare-dest",     0,  POPT_ARG_STRING, &compare_dest, 0, 0, 0 },
434    {"link-dest",        0,  POPT_ARG_STRING, 0,              OPT_LINK_DEST, 0, 0 },
435 +  {"link-by-hash",     0,  POPT_ARG_STRING, 0,              OPT_LINK_BY_HASH, 0, 0},
436    /* TODO: Should this take an optional int giving the compression level? */
437    {"compress",        'z', POPT_ARG_NONE,   &do_compression, 0, 0, 0 },
438    {"daemon",           0,  POPT_ARG_NONE,   &daemon_opt, 0, 0, 0 },
439 @@ -577,6 +580,19 @@
440                         return 0;
441  #endif
442  
443 +                case OPT_LINK_BY_HASH:
444 +#if HAVE_LINK
445 +                       link_by_hash_dir = (char *)poptGetOptArg(pc);
446 +                       checksum_seed = FIXED_CHECKSUM_SEED;
447 +                       break;
448 +#else
449 +                       snprintf(err_buf, sizeof err_buf,
450 +                                "hard links are not supported on this %s\n",
451 +                                am_server ? "server" : "client");
452 +                       rprintf(FERROR, "ERROR: %s", err_buf);
453 +                       return 0;
454 +#endif
455 +
456                 default:
457                         /* A large opt value means that set_refuse_options()
458                          * turned this option off (opt-BASE is its index). */
459 @@ -934,6 +950,11 @@
460                 args[ac++] = compare_dest;
461         }
462  
463 +       if (link_by_hash_dir && am_sender) {
464 +               args[ac++] = "--link-by-hash";
465 +               args[ac++] = link_by_hash_dir;
466 +       }
467 +
468         if (files_from && (!am_sender || remote_filesfrom_file)) {
469                 if (remote_filesfrom_file) {
470                         args[ac++] = "--files-from";
471 --- proto.h     2004-02-23 10:22:51.000000000 -0500
472 +++ proto.h     2004-02-23 11:06:03.000000000 -0500
473 @@ -93,6 +93,12 @@
474  void write_sum_head(int f, struct sum_struct *sum);
475  void recv_generator(char *fname, struct file_struct *file, int i, int f_out);
476  void generate_files(int f, struct file_list *flist, char *local_name);
477 +char* make_hash_name(struct file_struct *file);
478 +void kill_hashfile(struct hashfile_struct *hashfile);
479 +void kill_hashfiles(struct hashfile_struct *hashfiles);
480 +struct hashfile_struct *find_hashfiles(char *hashname, int64 size, long *fnbr);
481 +struct hashfile_struct *compare_hashfiles(int fd,struct hashfile_struct *files);
482 +int link_by_hash(char *fnametmp,char *fname,struct file_struct *file);
483  void init_hard_links(struct file_list *flist);
484  int hard_link_check(struct file_struct *file, int skip);
485  void do_hard_links(void);
486 --- receiver.c  2004-02-23 10:22:51.000000000 -0500
487 +++ receiver.c  2004-02-23 10:22:51.000000000 -0500
488 @@ -186,10 +186,11 @@
489  
490  
491  static int receive_data(int f_in,struct map_struct *mapbuf,int fd,char *fname,
492 -                       OFF_T total_size)
493 +                       OFF_T total_size,char *md4)
494  {
495         int i;
496         struct sum_struct sum;
497 +       struct mdfour mdfour_data;
498         unsigned int len;
499         OFF_T offset = 0;
500         OFF_T offset2;
501 @@ -199,7 +200,9 @@
502         char *map=NULL;
503  
504         read_sum_head(f_in, &sum);
505 -
506 +       if (md4)
507 +               mdfour_begin(&mdfour_data);
508 +       
509         sum_init();
510  
511         while ((i = recv_token(f_in, &data)) != 0) {
512 @@ -216,6 +219,8 @@
513                         cleanup_got_literal = 1;
514  
515                         sum_update(data,i);
516 +                       if (md4)
517 +                               mdfour_update(&mdfour_data,data,i);
518  
519                         if (fd != -1 && write_file(fd,data,i) != i) {
520                                 rprintf(FERROR, "write failed on %s: %s\n",
521 @@ -243,6 +248,8 @@
522  
523                         see_token(map, len);
524                         sum_update(map,len);
525 +                       if (md4)
526 +                               mdfour_update(&mdfour_data,map,len);
527                 }
528  
529                 if (fd != -1 && write_file(fd,map,len) != (int) len) {
530 @@ -265,6 +272,8 @@
531         }
532  
533         sum_end(file_sum1);
534 +       if (md4)
535 +               mdfour_result(&mdfour_data, (unsigned char*)md4);
536  
537         read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
538         if (verbose > 2) {
539 @@ -299,6 +308,7 @@
540         extern int preserve_perms;
541         extern int delete_after;
542         extern int orig_umask;
543 +       extern char *link_by_hash_dir;
544         struct stats initial_stats;
545  
546         if (verbose > 2) {
547 @@ -372,7 +382,7 @@
548                 if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
549                         rprintf(FERROR, "fstat %s failed: %s\n",
550                                 full_fname(fnamecmp), strerror(errno));
551 -                       receive_data(f_in,NULL,-1,NULL,file->length);
552 +                       receive_data(f_in,NULL,-1,NULL,file->length,NULL);
553                         close(fd1);
554                         continue;
555                 }
556 @@ -385,7 +395,7 @@
557                          */
558                         rprintf(FERROR,"recv_files: %s is a directory\n",
559                                 full_fname(fnamecmp));
560 -                       receive_data(f_in, NULL, -1, NULL, file->length);
561 +                       receive_data(f_in,NULL,-1,NULL,file->length,NULL);
562                         close(fd1);
563                         continue;
564                 }
565 @@ -437,7 +447,7 @@
566                 if (fd2 == -1) {
567                         rprintf(FERROR, "mkstemp %s failed: %s\n",
568                                 full_fname(fnametmp), strerror(errno));
569 -                       receive_data(f_in,mapbuf,-1,NULL,file->length);
570 +                       receive_data(f_in,mapbuf,-1,NULL,file->length,NULL);
571                         if (mapbuf) unmap_file(mapbuf);
572                         if (fd1 != -1) close(fd1);
573                         continue;
574 @@ -450,7 +460,12 @@
575                 }
576  
577                 /* recv file data */
578 -               recv_ok = receive_data(f_in,mapbuf,fd2,fname,file->length);
579 +#ifdef HAVE_LINK
580 +               if (link_by_hash_dir) {
581 +                       file->u.sum = (char*)malloc (MD4_SUM_LENGTH);
582 +               }
583 +#endif
584 +               recv_ok = receive_data(f_in,mapbuf,fd2,fname,file->length,file->u.sum);
585  
586                 log_recv(file, &initial_stats);
587  
588 --- rsync.c     2004-02-23 10:22:51.000000000 -0500
589 +++ rsync.c     2004-02-23 12:49:33.000000000 -0500
590 @@ -33,6 +33,7 @@
591  extern int preserve_gid;
592  extern int preserve_perms;
593  extern int make_backups;
594 +extern char *link_by_hash_dir;
595  
596  
597  /*
598 @@ -236,8 +237,13 @@
599         if (make_backups && !make_backup(fname))
600                 return;
601  
602 -       /* move tmp file over real file */
603 -       ret = robust_rename(fnametmp, fname, file->mode & INITACCESSPERMS);
604 +#ifdef HAVE_LINK
605 +       if (link_by_hash_dir)
606 +               ret = link_by_hash(fnametmp,fname,file);
607 +       else
608 +#endif
609 +               ret = robust_rename(fnametmp, fname, file->mode & INITACCESSPERMS);
610 +
611         if (ret != 0) {
612                 rprintf(FERROR, "%s %s -> \"%s\": %s\n",
613                     ret == -2 ? "copy" : "rename",
614 --- rsync.h     2004-02-23 10:22:51.000000000 -0500
615 +++ rsync.h     2004-02-23 12:42:59.000000000 -0500
616 @@ -513,6 +513,14 @@
617         int current_file_index;
618  };
619  
620 +struct hashfile_struct {
621 +       struct hashfile_struct *next;
622 +       struct hashfile_struct *prev;
623 +       char *name;
624 +       int fd;
625 +       uint32 nlink;
626 +};
627 +
628  
629  /* we need this function because of the silly way in which duplicate
630     entries are handled in the file lists - we can't change this