fixed a select bug which caused rsync to use far more cpu time than
[rsync/rsync.git] / flist.c
CommitLineData
c627d613
AT
1/*
2 Copyright (C) Andrew Tridgell 1996
3 Copyright (C) Paul Mackerras 1996
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18*/
19
20/* generate and receive file lists */
21
22#include "rsync.h"
23
43a481dc
AT
24extern int csum_length;
25
c627d613
AT
26extern int verbose;
27extern int am_server;
28extern int always_checksum;
71c46176 29extern int64 total_size;
c627d613
AT
30
31extern int cvs_exclude;
32
a06d19e3
AT
33extern int recurse;
34
c627d613
AT
35extern int one_file_system;
36extern int make_backups;
37extern int preserve_links;
dc5ddbcc 38extern int preserve_hard_links;
c627d613
AT
39extern int preserve_perms;
40extern int preserve_devices;
41extern int preserve_uid;
42extern int preserve_gid;
43extern int preserve_times;
6574b4f7 44extern int relative_paths;
82306bf6 45extern int copy_links;
f6c34742 46extern int remote_version;
6ba9279f 47extern int io_error;
c627d613 48
3a6a366f 49static char **local_exclude_list;
c627d613 50
bcacc18b 51int link_stat(const char *Path, STRUCT_STAT *Buffer)
82306bf6
AT
52{
53#if SUPPORT_LINKS
54 if (copy_links) {
bcacc18b 55 return do_stat(Path, Buffer);
82306bf6 56 } else {
bcacc18b 57 return do_lstat(Path, Buffer);
82306bf6
AT
58 }
59#else
bcacc18b 60 return do_stat(Path, Buffer);
82306bf6
AT
61#endif
62}
63
c627d613
AT
64/*
65 This function is used to check if a file should be included/excluded
66 from the list of files based on its name and type etc
67 */
bcacc18b 68static int match_file_name(char *fname,STRUCT_STAT *st)
c627d613
AT
69{
70 if (check_exclude(fname,local_exclude_list)) {
71 if (verbose > 2)
9486289c 72 rprintf(FINFO,"excluding file %s\n",fname);
c627d613
AT
73 return 0;
74 }
75 return 1;
76}
77
78/* used by the one_file_system code */
79static dev_t filesystem_dev;
80
81static void set_filesystem(char *fname)
82{
bcacc18b 83 STRUCT_STAT st;
82306bf6 84 if (link_stat(fname,&st) != 0) return;
c627d613
AT
85 filesystem_dev = st.st_dev;
86}
87
88
89static void send_directory(int f,struct file_list *flist,char *dir);
90
3a6a366f 91static char *flist_dir;
c627d613 92
3ec4dd97
AT
93static void clean_fname(char *name)
94{
95 char *p;
96 int l;
97 int modified = 1;
98
99 if (!name) return;
100
101 while (modified) {
102 modified = 0;
103
104 if ((p=strstr(name,"/./"))) {
105 modified = 1;
106 while (*p) {
107 p[0] = p[2];
108 p++;
109 }
110 }
111
112 if ((p=strstr(name,"//"))) {
113 modified = 1;
114 while (*p) {
115 p[0] = p[1];
116 p++;
117 }
118 }
4fe159a8 119
3ec4dd97
AT
120 if (strncmp(p=name,"./",2) == 0) {
121 modified = 1;
122 do {
123 p[0] = p[2];
124 } while (*p++);
125 }
4fe159a8 126
3ec4dd97
AT
127 l = strlen(p=name);
128 if (l > 1 && p[l-1] == '/') {
129 modified = 1;
130 p[l-1] = 0;
131 }
132 }
133}
134
135
136
3333ffbd 137void send_file_entry(struct file_struct *file,int f,unsigned base_flags)
c627d613 138{
182dca5c 139 unsigned char flags;
3a6a366f
AT
140 static time_t last_time;
141 static mode_t last_mode;
142 static dev_t last_rdev;
143 static uid_t last_uid;
144 static gid_t last_gid;
145 static char lastname[MAXPATHLEN];
3ec4dd97 146 char *fname;
4fe159a8 147 int l1,l2;
182dca5c 148
c627d613
AT
149 if (f == -1) return;
150
182dca5c
AT
151 if (!file) {
152 write_byte(f,0);
153 return;
154 }
155
3ec4dd97
AT
156 fname = f_name(file);
157
3333ffbd 158 flags = base_flags;
182dca5c
AT
159
160 if (file->mode == last_mode) flags |= SAME_MODE;
dc5ddbcc 161 if (file->rdev == last_rdev) flags |= SAME_RDEV;
182dca5c
AT
162 if (file->uid == last_uid) flags |= SAME_UID;
163 if (file->gid == last_gid) flags |= SAME_GID;
4fe159a8 164 if (file->modtime == last_time) flags |= SAME_TIME;
182dca5c 165
3ec4dd97
AT
166 for (l1=0;lastname[l1] && fname[l1] == lastname[l1];l1++) ;
167 l2 = strlen(fname) - l1;
4fe159a8
AT
168
169 if (l1 > 0) flags |= SAME_NAME;
170 if (l2 > 255) flags |= LONG_NAME;
d89322c4 171
4fe159a8
AT
172 write_byte(f,flags);
173 if (flags & SAME_NAME)
174 write_byte(f,l1);
175 if (flags & LONG_NAME)
176 write_int(f,l2);
9f3541e6 177 else
4fe159a8 178 write_byte(f,l2);
3ec4dd97 179 write_buf(f,fname+l1,l2);
4fe159a8 180
3a6a366f 181 write_longint(f,file->length);
4fe159a8
AT
182 if (!(flags & SAME_TIME))
183 write_int(f,(int)file->modtime);
182dca5c
AT
184 if (!(flags & SAME_MODE))
185 write_int(f,(int)file->mode);
f6c34742
AT
186 if (preserve_uid && !(flags & SAME_UID)) {
187 add_uid(file->uid);
188 write_int(f,(int)file->uid);
189 }
190 if (preserve_gid && !(flags & SAME_GID)) {
191 add_gid(file->gid);
192 write_int(f,(int)file->gid);
193 }
dc5ddbcc
AT
194 if (preserve_devices && IS_DEVICE(file->mode) && !(flags & SAME_RDEV))
195 write_int(f,(int)file->rdev);
c627d613
AT
196
197#if SUPPORT_LINKS
198 if (preserve_links && S_ISLNK(file->mode)) {
199 write_int(f,strlen(file->link));
200 write_buf(f,file->link,strlen(file->link));
201 }
202#endif
203
dc5ddbcc
AT
204#if SUPPORT_HARD_LINKS
205 if (preserve_hard_links && S_ISREG(file->mode)) {
3a6a366f
AT
206 write_int(f,(int)file->dev);
207 write_int(f,(int)file->inode);
dc5ddbcc
AT
208 }
209#endif
210
c627d613 211 if (always_checksum) {
1250f24e 212 write_buf(f,file->sum,csum_length);
c627d613 213 }
182dca5c
AT
214
215 last_mode = file->mode;
dc5ddbcc 216 last_rdev = file->rdev;
182dca5c
AT
217 last_uid = file->uid;
218 last_gid = file->gid;
4fe159a8
AT
219 last_time = file->modtime;
220
7a6421fa 221 strlcpy(lastname,fname,MAXPATHLEN-1);
13a1f792 222 lastname[MAXPATHLEN-1] = 0;
182dca5c
AT
223}
224
225
226
3333ffbd
AT
227static void receive_file_entry(struct file_struct **fptr,
228 unsigned flags,int f)
182dca5c 229{
3a6a366f
AT
230 static time_t last_time;
231 static mode_t last_mode;
232 static dev_t last_rdev;
233 static uid_t last_uid;
234 static gid_t last_gid;
3ec4dd97
AT
235 static char lastname[MAXPATHLEN];
236 char thisname[MAXPATHLEN];
4fe159a8 237 int l1=0,l2=0;
3ec4dd97
AT
238 char *p;
239 struct file_struct *file;
182dca5c 240
4fe159a8 241 if (flags & SAME_NAME)
9f3541e6 242 l1 = read_byte(f);
4fe159a8
AT
243
244 if (flags & LONG_NAME)
245 l2 = read_int(f);
246 else
247 l2 = read_byte(f);
182dca5c 248
3ec4dd97
AT
249 file = (struct file_struct *)malloc(sizeof(*file));
250 if (!file) out_of_memory("receive_file_entry");
dc5ddbcc 251 bzero((char *)file,sizeof(*file));
3ec4dd97
AT
252 (*fptr) = file;
253
575f2fca
AT
254 if (l2 >= MAXPATHLEN-l1) overflow("receive_file_entry");
255
7a6421fa 256 strlcpy(thisname,lastname,l1);
575f2fca 257 read_sbuf(f,&thisname[l1],l2);
3ec4dd97
AT
258 thisname[l1+l2] = 0;
259
7a6421fa 260 strlcpy(lastname,thisname,MAXPATHLEN-1);
3ec4dd97
AT
261 lastname[MAXPATHLEN-1] = 0;
262
263 clean_fname(thisname);
264
265 if ((p = strrchr(thisname,'/'))) {
266 static char *lastdir;
267 *p = 0;
268 if (lastdir && strcmp(thisname, lastdir)==0) {
269 file->dirname = lastdir;
270 } else {
271 file->dirname = strdup(thisname);
272 lastdir = file->dirname;
273 }
274 file->basename = strdup(p+1);
275 } else {
276 file->dirname = NULL;
277 file->basename = strdup(thisname);
278 }
dc5ddbcc 279
3ec4dd97 280 if (!file->basename) out_of_memory("receive_file_entry 1");
182dca5c 281
182dca5c 282
3333ffbd 283 file->flags = flags;
3a6a366f 284 file->length = read_longint(f);
4fe159a8 285 file->modtime = (flags & SAME_TIME) ? last_time : (time_t)read_int(f);
182dca5c
AT
286 file->mode = (flags & SAME_MODE) ? last_mode : (mode_t)read_int(f);
287 if (preserve_uid)
288 file->uid = (flags & SAME_UID) ? last_uid : (uid_t)read_int(f);
289 if (preserve_gid)
290 file->gid = (flags & SAME_GID) ? last_gid : (gid_t)read_int(f);
291 if (preserve_devices && IS_DEVICE(file->mode))
dc5ddbcc 292 file->rdev = (flags & SAME_RDEV) ? last_rdev : (dev_t)read_int(f);
182dca5c 293
182dca5c
AT
294 if (preserve_links && S_ISLNK(file->mode)) {
295 int l = read_int(f);
296 file->link = (char *)malloc(l+1);
6dd1782c 297 if (!file->link) out_of_memory("receive_file_entry 2");
575f2fca 298 read_sbuf(f,file->link,l);
182dca5c 299 }
dc5ddbcc
AT
300
301#if SUPPORT_HARD_LINKS
302 if (preserve_hard_links && S_ISREG(file->mode)) {
303 file->dev = read_int(f);
304 file->inode = read_int(f);
305 }
306#endif
182dca5c 307
2d0bb8eb
AT
308 if (always_checksum) {
309 file->sum = (char *)malloc(MD4_SUM_LENGTH);
310 if (!file->sum) out_of_memory("md4 sum");
311 read_buf(f,file->sum,csum_length);
312 }
182dca5c
AT
313
314 last_mode = file->mode;
dc5ddbcc 315 last_rdev = file->rdev;
182dca5c
AT
316 last_uid = file->uid;
317 last_gid = file->gid;
4fe159a8 318 last_time = file->modtime;
c627d613
AT
319}
320
321
0c5f37d9
AT
322/* determine if a file in a different filesstem should be skipped
323 when one_file_system is set. We bascally only want to include
324 the mount points - but they can be hard to find! */
bcacc18b 325static int skip_filesystem(char *fname, STRUCT_STAT *st)
0c5f37d9 326{
bcacc18b 327 STRUCT_STAT st2;
0c5f37d9
AT
328 char *p = strrchr(fname, '/');
329
330 /* skip all but directories */
331 if (!S_ISDIR(st->st_mode)) return 1;
332
333 /* if its not a subdirectory then allow */
334 if (!p) return 0;
335
336 *p = 0;
337 if (link_stat(fname, &st2)) {
338 *p = '/';
339 return 0;
340 }
341 *p = '/';
342
343 return (st2.st_dev != filesystem_dev);
344}
4fe159a8 345
a06d19e3 346static struct file_struct *make_file(char *fname)
c627d613 347{
3ec4dd97 348 struct file_struct *file;
bcacc18b 349 STRUCT_STAT st;
3ec4dd97
AT
350 char sum[SUM_LENGTH];
351 char *p;
352 char cleaned_name[MAXPATHLEN];
353
7a6421fa 354 strlcpy(cleaned_name, fname, MAXPATHLEN-1);
3ec4dd97
AT
355 cleaned_name[MAXPATHLEN-1] = 0;
356 clean_fname(cleaned_name);
357 fname = cleaned_name;
358
359 bzero(sum,SUM_LENGTH);
360
361 if (link_stat(fname,&st) != 0) {
6ba9279f 362 io_error = 1;
9486289c 363 rprintf(FERROR,"%s: %s\n",
3ec4dd97
AT
364 fname,strerror(errno));
365 return NULL;
366 }
c627d613 367
3ec4dd97 368 if (S_ISDIR(st.st_mode) && !recurse) {
9486289c 369 rprintf(FINFO,"skipping directory %s\n",fname);
3ec4dd97
AT
370 return NULL;
371 }
372
0c5f37d9
AT
373 if (one_file_system && st.st_dev != filesystem_dev) {
374 if (skip_filesystem(fname, &st))
375 return NULL;
376 }
3ec4dd97
AT
377
378 if (!match_file_name(fname,&st))
379 return NULL;
380
381 if (verbose > 2)
9486289c 382 rprintf(FINFO,"make_file(%s)\n",fname);
3ec4dd97
AT
383
384 file = (struct file_struct *)malloc(sizeof(*file));
385 if (!file) out_of_memory("make_file");
386 bzero((char *)file,sizeof(*file));
387
388 if ((p = strrchr(fname,'/'))) {
389 static char *lastdir;
390 *p = 0;
391 if (lastdir && strcmp(fname, lastdir)==0) {
392 file->dirname = lastdir;
393 } else {
394 file->dirname = strdup(fname);
395 lastdir = file->dirname;
396 }
397 file->basename = strdup(p+1);
398 *p = '/';
399 } else {
400 file->dirname = NULL;
401 file->basename = strdup(fname);
402 }
c627d613 403
3ec4dd97
AT
404 file->modtime = st.st_mtime;
405 file->length = st.st_size;
406 file->mode = st.st_mode;
407 file->uid = st.st_uid;
408 file->gid = st.st_gid;
409 file->dev = st.st_dev;
410 file->inode = st.st_ino;
c627d613 411#ifdef HAVE_ST_RDEV
3ec4dd97 412 file->rdev = st.st_rdev;
c627d613
AT
413#endif
414
415#if SUPPORT_LINKS
3ec4dd97
AT
416 if (S_ISLNK(st.st_mode)) {
417 int l;
418 char lnk[MAXPATHLEN];
419 if ((l=readlink(fname,lnk,MAXPATHLEN-1)) == -1) {
6ba9279f 420 io_error=1;
9486289c 421 rprintf(FERROR,"readlink %s : %s\n",
3ec4dd97
AT
422 fname,strerror(errno));
423 return NULL;
424 }
425 lnk[l] = 0;
426 file->link = strdup(lnk);
427 }
c627d613
AT
428#endif
429
1250f24e 430 if (always_checksum) {
2d0bb8eb
AT
431 file->sum = (char *)malloc(MD4_SUM_LENGTH);
432 if (!file->sum) out_of_memory("md4 sum");
1250f24e
AT
433 /* drat. we have to provide a null checksum for non-regular
434 files in order to be compatible with earlier versions
435 of rsync */
436 if (S_ISREG(st.st_mode)) {
437 file_checksum(fname,file->sum,st.st_size);
438 } else {
439 memset(file->sum, 0, MD4_SUM_LENGTH);
440 }
3ec4dd97 441 }
c627d613 442
3ec4dd97
AT
443 if (flist_dir) {
444 static char *lastdir;
445 if (lastdir && strcmp(lastdir, flist_dir)==0) {
446 file->basedir = lastdir;
447 } else {
448 file->basedir = strdup(flist_dir);
449 lastdir = file->basedir;
450 }
451 } else {
452 file->basedir = NULL;
453 }
c627d613 454
3ec4dd97
AT
455 if (!S_ISDIR(st.st_mode))
456 total_size += st.st_size;
c627d613 457
3ec4dd97 458 return file;
c627d613
AT
459}
460
461
462
649d65ed 463static void send_file_name(int f,struct file_list *flist,char *fname,
3333ffbd 464 int recursive, unsigned base_flags)
c627d613
AT
465{
466 struct file_struct *file;
467
a06d19e3 468 file = make_file(fname);
c627d613
AT
469
470 if (!file) return;
471
472 if (flist->count >= flist->malloced) {
3ec4dd97
AT
473 if (flist->malloced < 1000)
474 flist->malloced += 1000;
f9c51620 475 else
3ec4dd97
AT
476 flist->malloced *= 2;
477 flist->files = (struct file_struct **)realloc(flist->files,
478 sizeof(flist->files[0])*
479 flist->malloced);
f9c51620
AT
480 if (!flist->files)
481 out_of_memory("send_file_name");
c627d613
AT
482 }
483
3ec4dd97
AT
484 if (strcmp(file->basename,"")) {
485 flist->files[flist->count++] = file;
3333ffbd 486 send_file_entry(file,f,base_flags);
c627d613
AT
487 }
488
649d65ed 489 if (S_ISDIR(file->mode) && recursive) {
c627d613 490 char **last_exclude_list = local_exclude_list;
3ec4dd97 491 send_directory(f,flist,f_name(file));
c627d613
AT
492 local_exclude_list = last_exclude_list;
493 return;
494 }
495}
496
497
498
499static void send_directory(int f,struct file_list *flist,char *dir)
500{
3ec4dd97
AT
501 DIR *d;
502 struct dirent *di;
503 char fname[MAXPATHLEN];
504 int l;
505 char *p;
506
507 d = opendir(dir);
508 if (!d) {
6ba9279f 509 io_error = 1;
9486289c 510 rprintf(FERROR,"%s: %s\n",
3ec4dd97
AT
511 dir,strerror(errno));
512 return;
513 }
c627d613 514
7a6421fa 515 strlcpy(fname,dir,MAXPATHLEN-1);
3ec4dd97
AT
516 l = strlen(fname);
517 if (fname[l-1] != '/') {
518 if (l == MAXPATHLEN-1) {
6ba9279f 519 io_error = 1;
9486289c 520 rprintf(FERROR,"skipping long-named directory %s\n",fname);
3ec4dd97
AT
521 closedir(d);
522 return;
523 }
524 strcat(fname,"/");
525 l++;
526 }
527 p = fname + strlen(fname);
c627d613 528
3ec4dd97
AT
529 if (cvs_exclude) {
530 if (strlen(fname) + strlen(".cvsignore") <= MAXPATHLEN-1) {
531 strcpy(p,".cvsignore");
532 local_exclude_list = make_exclude_list(fname,NULL,0);
533 } else {
6ba9279f 534 io_error = 1;
9486289c 535 rprintf(FINFO,"cannot cvs-exclude in long-named directory %s\n",fname);
3ec4dd97
AT
536 }
537 }
538
539 for (di=readdir(d); di; di=readdir(d)) {
d6e6ecbd
AT
540 char *dname = d_name(di);
541 if (strcmp(dname,".")==0 ||
542 strcmp(dname,"..")==0)
3ec4dd97 543 continue;
7a6421fa 544 strlcpy(p,dname,MAXPATHLEN-(l+1));
3333ffbd 545 send_file_name(f,flist,fname,recurse,FLAG_DELETE);
3ec4dd97 546 }
c627d613 547
3ec4dd97 548 closedir(d);
c627d613
AT
549}
550
551
552
a06d19e3 553struct file_list *send_file_list(int f,int argc,char *argv[])
c627d613 554{
649d65ed 555 int i,l;
bcacc18b 556 STRUCT_STAT st;
649d65ed
AT
557 char *p,*dir;
558 char dbuf[MAXPATHLEN];
559 char lastpath[MAXPATHLEN]="";
560 struct file_list *flist;
561
562 if (verbose && recurse && !am_server && f != -1) {
9486289c
AT
563 rprintf(FINFO,"building file list ... ");
564 rflush(FINFO);
649d65ed 565 }
c627d613 566
649d65ed
AT
567 flist = (struct file_list *)malloc(sizeof(flist[0]));
568 if (!flist) out_of_memory("send_file_list");
c627d613 569
649d65ed
AT
570 flist->count=0;
571 flist->malloced = 1000;
572 flist->files = (struct file_struct **)malloc(sizeof(flist->files[0])*
573 flist->malloced);
574 if (!flist->files) out_of_memory("send_file_list");
c627d613 575
649d65ed
AT
576 for (i=0;i<argc;i++) {
577 char fname2[MAXPATHLEN];
578 char *fname = fname2;
c627d613 579
7a6421fa 580 strlcpy(fname,argv[i],MAXPATHLEN-1);
c627d613 581
649d65ed
AT
582 l = strlen(fname);
583 if (l != 1 && fname[l-1] == '/') {
584 strcat(fname,".");
585 }
c627d613 586
649d65ed 587 if (link_stat(fname,&st) != 0) {
6ba9279f 588 io_error=1;
9486289c 589 rprintf(FERROR,"%s : %s\n",fname,strerror(errno));
649d65ed
AT
590 continue;
591 }
c627d613 592
649d65ed 593 if (S_ISDIR(st.st_mode) && !recurse) {
9486289c 594 rprintf(FINFO,"skipping directory %s\n",fname);
649d65ed
AT
595 continue;
596 }
c627d613 597
649d65ed
AT
598 dir = NULL;
599
600 if (!relative_paths) {
601 p = strrchr(fname,'/');
602 if (p) {
603 *p = 0;
604 if (p == fname)
605 dir = "/";
606 else
607 dir = fname;
608 fname = p+1;
609 }
610 } else if (f != -1 && (p=strrchr(fname,'/'))) {
611 /* this ensures we send the intermediate directories,
612 thus getting their permissions right */
613 *p = 0;
614 if (strcmp(lastpath,fname)) {
615 strcpy(lastpath, fname);
616 *p = '/';
617 for (p=fname+1; (p=strchr(p,'/')); p++) {
618 *p = 0;
3333ffbd 619 send_file_name(f, flist, fname, 0, 0);
649d65ed
AT
620 *p = '/';
621 }
622 } else {
623 *p = '/';
624 }
625 }
626
627 if (!*fname)
628 fname = ".";
629
630 if (dir && *dir) {
631 if (getcwd(dbuf,MAXPATHLEN-1) == NULL) {
9486289c 632 rprintf(FERROR,"getwd : %s\n",strerror(errno));
649d65ed
AT
633 exit_cleanup(1);
634 }
635 if (chdir(dir) != 0) {
6ba9279f 636 io_error=1;
9486289c 637 rprintf(FERROR,"chdir %s : %s\n",
649d65ed
AT
638 dir,strerror(errno));
639 continue;
640 }
641 flist_dir = dir;
642 if (one_file_system)
643 set_filesystem(fname);
3333ffbd 644 send_file_name(f,flist,fname,recurse,FLAG_DELETE);
649d65ed
AT
645 flist_dir = NULL;
646 if (chdir(dbuf) != 0) {
9486289c 647 rprintf(FERROR,"chdir %s : %s\n",
649d65ed
AT
648 dbuf,strerror(errno));
649 exit_cleanup(1);
650 }
651 continue;
652 }
653
654 if (one_file_system)
655 set_filesystem(fname);
3333ffbd 656 send_file_name(f,flist,fname,recurse,FLAG_DELETE);
649d65ed 657 }
dc5ddbcc 658
649d65ed 659 if (f != -1) {
3333ffbd 660 send_file_entry(NULL,f,0);
649d65ed
AT
661 write_flush(f);
662 }
c627d613 663
649d65ed 664 if (verbose && recurse && !am_server && f != -1)
9486289c 665 rprintf(FINFO,"done\n");
649d65ed
AT
666
667 clean_flist(flist);
668
669 /* now send the uid/gid list. This was introduced in protocol
670 version 15 */
671 if (f != -1 && remote_version >= 15) {
672 send_uid_list(f);
673 }
f6c34742 674
6ba9279f
AT
675 /* if protocol version is >= 17 then send the io_error flag */
676 if (f != -1 && remote_version >= 17) {
677 write_int(f, io_error);
678 }
679
17faa41c 680 if (verbose > 2)
9486289c 681 rprintf(FINFO,"send_file_list done\n");
17faa41c 682
649d65ed 683 return flist;
c627d613
AT
684}
685
686
687struct file_list *recv_file_list(int f)
688{
c627d613 689 struct file_list *flist;
182dca5c 690 unsigned char flags;
c627d613 691
a06d19e3 692 if (verbose && recurse && !am_server) {
9486289c
AT
693 rprintf(FINFO,"receiving file list ... ");
694 rflush(FINFO);
a06d19e3 695 }
c627d613
AT
696
697 flist = (struct file_list *)malloc(sizeof(flist[0]));
698 if (!flist)
699 goto oom;
700
701 flist->count=0;
3ec4dd97
AT
702 flist->malloced=1000;
703 flist->files = (struct file_struct **)malloc(sizeof(flist->files[0])*
704 flist->malloced);
c627d613
AT
705 if (!flist->files)
706 goto oom;
707
708
182dca5c 709 for (flags=read_byte(f); flags; flags=read_byte(f)) {
c627d613
AT
710 int i = flist->count;
711
712 if (i >= flist->malloced) {
3ec4dd97
AT
713 if (flist->malloced < 1000)
714 flist->malloced += 1000;
f9c51620 715 else
3ec4dd97
AT
716 flist->malloced *= 2;
717 flist->files =(struct file_struct **)realloc(flist->files,
718 sizeof(flist->files[0])*
719 flist->malloced);
f9c51620
AT
720 if (!flist->files)
721 goto oom;
c627d613
AT
722 }
723
182dca5c 724 receive_file_entry(&flist->files[i],flags,f);
c627d613 725
3ec4dd97
AT
726 if (S_ISREG(flist->files[i]->mode))
727 total_size += flist->files[i]->length;
c627d613
AT
728
729 flist->count++;
730
731 if (verbose > 2)
9486289c 732 rprintf(FINFO,"recv_file_name(%s)\n",f_name(flist->files[i]));
c627d613
AT
733 }
734
735
736 if (verbose > 2)
9486289c 737 rprintf(FINFO,"received %d names\n",flist->count);
c627d613
AT
738
739 clean_flist(flist);
740
a06d19e3 741 if (verbose && recurse && !am_server) {
9486289c 742 rprintf(FINFO,"done\n");
a06d19e3
AT
743 }
744
f6c34742
AT
745 /* now recv the uid/gid list. This was introduced in protocol version 15 */
746 if (f != -1 && remote_version >= 15) {
747 recv_uid_list(f, flist);
748 }
749
6ba9279f
AT
750 /* if protocol version is >= 17 then recv the io_error flag */
751 if (f != -1 && remote_version >= 17) {
752 io_error |= read_int(f);
753 }
754
17faa41c 755 if (verbose > 2)
9486289c 756 rprintf(FINFO,"recv_file_list done\n");
17faa41c 757
c627d613
AT
758 return flist;
759
760oom:
761 out_of_memory("recv_file_list");
762 return NULL; /* not reached */
763}
764
765
3ec4dd97 766int file_compare(struct file_struct **f1,struct file_struct **f2)
c627d613 767{
3ec4dd97
AT
768 if (!(*f1)->basename && !(*f2)->basename) return 0;
769 if (!(*f1)->basename) return -1;
770 if (!(*f2)->basename) return 1;
771 if ((*f1)->dirname == (*f2)->dirname)
772 return strcmp((*f1)->basename, (*f2)->basename);
773 return strcmp(f_name(*f1),f_name(*f2));
c627d613
AT
774}
775
776
777int flist_find(struct file_list *flist,struct file_struct *f)
778{
d966ee25
AT
779 int low=0,high=flist->count-1;
780
781 if (flist->count <= 0) return -1;
782
783 while (low != high) {
784 int mid = (low+high)/2;
3ec4dd97 785 int ret = file_compare(&flist->files[flist_up(flist, mid)],&f);
d966ee25
AT
786 if (ret == 0) return flist_up(flist, mid);
787 if (ret > 0) {
788 high=mid;
789 } else {
790 low=mid+1;
791 }
792 }
793
3ec4dd97 794 if (file_compare(&flist->files[flist_up(flist,low)],&f) == 0)
d966ee25
AT
795 return flist_up(flist,low);
796 return -1;
c627d613
AT
797}
798
799
3ec4dd97
AT
800/*
801 * free up one file
802 */
803static void free_file(struct file_struct *file)
c627d613 804{
3ec4dd97
AT
805 if (!file) return;
806 if (file->basename) free(file->basename);
807 if (file->link) free(file->link);
0b910560 808 if (file->sum) free(file->sum);
3ec4dd97 809 bzero((char *)file, sizeof(*file));
3ec4dd97 810}
c627d613 811
c627d613 812
3ec4dd97
AT
813/*
814 * free up all elements in a flist
815 */
816void flist_free(struct file_list *flist)
817{
818 int i;
819 for (i=1;i<flist->count;i++) {
820 free_file(flist->files[i]);
649d65ed 821 free(flist->files[i]);
3ec4dd97
AT
822 }
823 bzero((char *)flist->files, sizeof(flist->files[0])*flist->count);
824 free(flist->files);
825 bzero((char *)flist, sizeof(*flist));
826 free(flist);
c627d613
AT
827}
828
829
830/*
831 * This routine ensures we don't have any duplicate names in our file list.
832 * duplicate names can cause corruption because of the pipelining
833 */
834void clean_flist(struct file_list *flist)
835{
3ec4dd97 836 int i;
c627d613 837
3ec4dd97
AT
838 if (!flist || flist->count == 0)
839 return;
c627d613 840
3ec4dd97
AT
841 qsort(flist->files,flist->count,
842 sizeof(flist->files[0]),
843 (int (*)())file_compare);
844
845 for (i=1;i<flist->count;i++) {
846 if (flist->files[i]->basename &&
649d65ed 847 flist->files[i-1]->basename &&
3ec4dd97
AT
848 strcmp(f_name(flist->files[i]),
849 f_name(flist->files[i-1])) == 0) {
850 if (verbose > 1 && !am_server)
9486289c 851 rprintf(FINFO,"removing duplicate name %s from file list %d\n",
3ec4dd97
AT
852 f_name(flist->files[i-1]),i-1);
853 free_file(flist->files[i]);
3ec4dd97
AT
854 }
855 }
856}
857
858
859/*
860 * return the full filename of a flist entry
861 */
862char *f_name(struct file_struct *f)
863{
864 static char names[10][MAXPATHLEN];
865 static int n;
866 char *p = names[n];
867
649d65ed 868 if (!f || !f->basename) return NULL;
3ec4dd97
AT
869
870 n = (n+1)%10;
871
872 if (f->dirname) {
873 sprintf(p, "%s/%s", f->dirname, f->basename);
874 } else {
e45e0093 875 strlcpy(p, f->basename, MAXPATHLEN-1);
3ec4dd97
AT
876 }
877
878 return p;
c627d613
AT
879}
880