2 Copyright (C) Andrew Tridgell 1996
3 Copyright (C) Paul Mackerras 1996
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.
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.
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.
22 extern int csum_length;
26 extern int always_checksum;
27 extern time_t starttime;
29 extern int remote_version;
31 extern char *backup_suffix;
34 extern int whole_file;
35 extern int block_size;
36 extern int update_only;
37 extern int make_backups;
38 extern int preserve_links;
39 extern int preserve_hard_links;
40 extern int preserve_perms;
41 extern int preserve_devices;
42 extern int preserve_uid;
43 extern int preserve_gid;
44 extern int preserve_times;
46 extern int ignore_times;
48 extern int delete_mode;
49 extern int cvs_exclude;
51 extern int relative_paths;
52 extern int io_timeout;
58 static void free_sums(struct sum_struct *s)
60 if (s->sums) free(s->sums);
66 * delete a file or directory. If force_delet is set then delete
69 static int delete_file(char *fname)
74 extern int force_delete;
78 if (do_unlink(fname) == 0 || errno == ENOENT) return 0;
81 ret = do_lstat(fname, &st);
83 ret = do_stat(fname, &st);
86 rprintf(FERROR,"stat(%s) : %s\n", fname, strerror(errno));
90 if (!S_ISDIR(st.st_mode)) {
91 rprintf(FERROR,"unlink(%s) : %s\n", fname, strerror(errno));
95 if (do_rmdir(fname) == 0 || errno == ENOENT) return 0;
96 if (!force_delete || (errno != ENOTEMPTY && errno != EEXIST)) {
97 rprintf(FERROR,"rmdir(%s) : %s\n", fname, strerror(errno));
101 /* now we do a recsursive delete on the directory ... */
104 rprintf(FERROR,"opendir(%s): %s\n",
105 fname,strerror(errno));
109 for (di=readdir(d); di; di=readdir(d)) {
110 char *dname = d_name(di);
111 if (strcmp(dname,".")==0 ||
112 strcmp(dname,"..")==0)
114 slprintf(buf, sizeof(buf)-1, "%s/%s", fname, dname);
116 rprintf(FINFO,"deleting %s\n", buf);
117 if (delete_file(buf) != 0) {
125 if (do_rmdir(fname) != 0) {
126 rprintf(FERROR,"rmdir(%s) : %s\n", fname, strerror(errno));
134 send a sums struct down a fd
136 static void send_sums(struct sum_struct *s,int f_out)
140 /* tell the other guy how many we are going to be doing and how many
141 bytes there are in the last chunk */
142 write_int(f_out,s?s->count:0);
143 write_int(f_out,s?s->n:block_size);
144 write_int(f_out,s?s->remainder:0);
146 for (i=0;i<s->count;i++) {
147 write_int(f_out,s->sums[i].sum1);
148 write_buf(f_out,s->sums[i].sum2,csum_length);
155 generate a stream of signatures/checksums that describe a buffer
157 generate approximately one checksum every n bytes
159 static struct sum_struct *generate_sums(struct map_struct *buf,OFF_T len,int n)
162 struct sum_struct *s;
165 int remainder = (len%block_len);
168 count = (len+(block_len-1))/block_len;
170 s = (struct sum_struct *)malloc(sizeof(*s));
171 if (!s) out_of_memory("generate_sums");
174 s->remainder = remainder;
184 rprintf(FINFO,"count=%d rem=%d n=%d flength=%d\n",
185 s->count,s->remainder,s->n,(int)s->flength);
187 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
188 if (!s->sums) out_of_memory("generate_sums");
190 for (i=0;i<count;i++) {
192 char *map = map_ptr(buf,offset,n1);
194 s->sums[i].sum1 = get_checksum1(map,n1);
195 get_checksum2(map,n1,s->sums[i].sum2);
197 s->sums[i].offset = offset;
202 rprintf(FINFO,"chunk[%d] offset=%d len=%d sum1=%08x\n",
203 i,(int)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
214 receive the checksums for a buffer
216 static struct sum_struct *receive_sums(int f)
218 struct sum_struct *s;
222 s = (struct sum_struct *)malloc(sizeof(*s));
223 if (!s) out_of_memory("receive_sums");
225 s->count = read_int(f);
227 s->remainder = read_int(f);
231 rprintf(FINFO,"count=%d n=%d rem=%d\n",
232 s->count,s->n,s->remainder);
237 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
238 if (!s->sums) out_of_memory("receive_sums");
240 for (i=0;i<s->count;i++) {
241 s->sums[i].sum1 = read_int(f);
242 read_buf(f,s->sums[i].sum2,csum_length);
244 s->sums[i].offset = offset;
247 if (i == s->count-1 && s->remainder != 0) {
248 s->sums[i].len = s->remainder;
250 s->sums[i].len = s->n;
252 offset += s->sums[i].len;
255 rprintf(FINFO,"chunk[%d] len=%d offset=%d sum1=%08x\n",
256 i,s->sums[i].len,(int)s->sums[i].offset,s->sums[i].sum1);
265 static int set_perms(char *fname,struct file_struct *file,STRUCT_STAT *st,
270 extern int am_daemon;
272 if (dry_run) return 0;
275 if (link_stat(fname,&st2) != 0) {
276 rprintf(FERROR,"stat %s : %s\n",fname,strerror(errno));
282 if (preserve_times && !S_ISLNK(st->st_mode) &&
283 st->st_mtime != file->modtime) {
285 if (set_modtime(fname,file->modtime) != 0) {
286 rprintf(FERROR,"failed to set times on %s : %s\n",
287 fname,strerror(errno));
293 if (preserve_perms && !S_ISLNK(st->st_mode) &&
294 st->st_mode != file->mode) {
296 if (do_chmod(fname,file->mode) != 0) {
297 rprintf(FERROR,"failed to set permissions on %s : %s\n",
298 fname,strerror(errno));
304 if ((am_root || !am_daemon) &&
305 ((am_root && preserve_uid && st->st_uid != file->uid) ||
306 (preserve_gid && st->st_gid != file->gid))) {
308 (am_root&&preserve_uid)?file->uid:-1,
309 preserve_gid?file->gid:-1) != 0) {
310 if (preserve_uid && st->st_uid != file->uid)
312 if (verbose>1 || preserve_uid)
313 rprintf(FERROR,"chown %s : %s\n",
314 fname,strerror(errno));
320 if (verbose > 1 && report) {
322 rprintf(FINFO,"%s\n",fname);
324 rprintf(FINFO,"%s is uptodate\n",fname);
330 /* choose whether to skip a particular file */
331 static int skip_file(char *fname,
332 struct file_struct *file, STRUCT_STAT *st)
334 if (st->st_size != file->length) {
338 /* if always checksum is set then we use the checksum instead
339 of the file time to determine whether to sync */
340 if (always_checksum && S_ISREG(st->st_mode)) {
341 char sum[MD4_SUM_LENGTH];
342 file_checksum(fname,sum,st->st_size);
343 return (memcmp(sum,file->sum,csum_length) == 0);
350 return (st->st_mtime == file->modtime);
354 /* use a larger block size for really big files */
355 int adapt_block_size(struct file_struct *file, int bsize)
357 int ret = file->length / (10000); /* rough heuristic */
358 ret = ret & ~15; /* multiple of 16 */
359 if (ret < bsize) ret = bsize;
360 if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
364 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
368 struct map_struct *buf;
369 struct sum_struct *s;
371 struct file_struct *file = flist->files[i];
374 rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
376 statret = link_stat(fname,&st);
378 if (S_ISDIR(file->mode)) {
380 if (statret == 0 && !S_ISDIR(st.st_mode)) {
381 if (do_unlink(fname) != 0) {
382 rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
387 if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
388 if (!(relative_paths && errno==ENOENT &&
389 create_directory_path(fname)==0 &&
390 do_mkdir(fname,file->mode)==0)) {
391 rprintf(FERROR,"mkdir %s : %s (2)\n",
392 fname,strerror(errno));
395 if (set_perms(fname,file,NULL,0) && verbose)
396 rprintf(FINFO,"%s/\n",fname);
400 if (preserve_links && S_ISLNK(file->mode)) {
402 char lnk[MAXPATHLEN];
405 l = readlink(fname,lnk,MAXPATHLEN-1);
408 if (strcmp(lnk,file->link) == 0) {
409 set_perms(fname,file,&st,1);
415 if (do_symlink(file->link,fname) != 0) {
416 rprintf(FERROR,"link %s -> %s : %s\n",
417 fname,file->link,strerror(errno));
419 set_perms(fname,file,NULL,0);
421 rprintf(FINFO,"%s -> %s\n",
429 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
431 st.st_mode != file->mode ||
432 st.st_rdev != file->rdev) {
435 rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
436 fname,(int)file->mode,(int)file->rdev);
437 if (do_mknod(fname,file->mode,file->rdev) != 0) {
438 rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
440 set_perms(fname,file,NULL,0);
442 rprintf(FINFO,"%s\n",fname);
445 set_perms(fname,file,&st,1);
451 if (preserve_hard_links && check_hard_link(file)) {
453 rprintf(FINFO,"%s is a hard link\n",f_name(file));
457 if (!S_ISREG(file->mode)) {
458 rprintf(FINFO,"skipping non-regular file %s\n",fname);
463 if (errno == ENOENT) {
465 if (!dry_run) send_sums(NULL,f_out);
468 rprintf(FERROR,"recv_generator failed to open %s\n",fname);
473 if (!S_ISREG(st.st_mode)) {
474 if (delete_file(fname) != 0) {
478 /* now pretend the file didn't exist */
480 if (!dry_run) send_sums(NULL,f_out);
484 if (update_only && st.st_mtime > file->modtime) {
486 rprintf(FINFO,"%s is newer\n",fname);
490 if (skip_file(fname, file, &st)) {
491 set_perms(fname,file,&st,1);
502 send_sums(NULL,f_out);
507 fd = open(fname,O_RDONLY);
510 rprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
511 rprintf(FERROR,"skipping %s\n",fname);
515 if (st.st_size > 0) {
516 buf = map_file(fd,st.st_size);
522 rprintf(FINFO,"gen mapped %s of size %d\n",fname,(int)st.st_size);
524 s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
527 rprintf(FINFO,"sending sums for %d\n",i);
534 if (buf) unmap_file(buf);
541 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
543 int i,n,remainder,len,count;
547 static char file_sum1[MD4_SUM_LENGTH];
548 static char file_sum2[MD4_SUM_LENGTH];
551 count = read_int(f_in);
553 remainder = read_int(f_in);
557 for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
560 rprintf(FINFO,"data recv %d at %d\n",i,(int)offset);
564 if (fd != -1 && write_file(fd,data,i) != i) {
565 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
573 if (i == count-1 && remainder != 0)
577 rprintf(FINFO,"chunk[%d] of size %d at %d offset=%d\n",
578 i,len,(int)offset2,(int)offset);
580 map = map_ptr(buf,offset2,len);
585 if (fd != -1 && write_file(fd,map,len) != len) {
586 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
593 if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
594 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
600 if (remote_version >= 14) {
601 read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
603 rprintf(FINFO,"got file_sum\n");
604 if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
611 static void delete_one(struct file_struct *f)
613 if (!S_ISDIR(f->mode)) {
614 if (do_unlink(f_name(f)) != 0) {
615 rprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
616 } else if (verbose) {
617 rprintf(FINFO,"deleting %s\n",f_name(f));
620 if (do_rmdir(f_name(f)) != 0) {
621 if (errno != ENOTEMPTY && errno != EEXIST)
622 rprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
623 } else if (verbose) {
624 rprintf(FINFO,"deleting directory %s\n",f_name(f));
631 static struct delete_list {
635 static int dlist_len, dlist_alloc_len;
637 static void add_delete_entry(struct file_struct *file)
639 if (dlist_len == dlist_alloc_len) {
640 dlist_alloc_len += 1024;
642 delete_list = (struct delete_list *)malloc(sizeof(delete_list[0])*dlist_alloc_len);
644 delete_list = (struct delete_list *)realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
646 if (!delete_list) out_of_memory("add_delete_entry");
649 delete_list[dlist_len].dev = file->dev;
650 delete_list[dlist_len].inode = file->inode;
654 rprintf(FINFO,"added %s to delete list\n", f_name(file));
657 /* yuck! This function wouldn't have been necessary if I had the sorting
658 algorithm right. Unfortunately fixing the sorting algorithm would introduce
659 a backward incompatibility as file list indexes are sent over the link.
661 static int delete_already_done(struct file_list *flist,int j)
666 if (link_stat(f_name(flist->files[j]), &st)) return 1;
668 for (i=0;i<dlist_len;i++) {
669 if (st.st_ino == delete_list[i].inode &&
670 st.st_dev == delete_list[i].dev)
678 /* this deletes any files on the receiving side that are not present
679 on the sending side. For version 1.6.4 I have changed the behaviour
680 to match more closely what most people seem to expect of this option */
681 static void delete_files(struct file_list *flist)
683 struct file_list *local_file_list;
691 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
695 for (j=0;j<flist->count;j++) {
696 if (!S_ISDIR(flist->files[j]->mode) ||
697 !(flist->files[j]->flags & FLAG_DELETE)) continue;
699 if (remote_version < 19 &&
700 delete_already_done(flist, j)) continue;
702 name = strdup(f_name(flist->files[j]));
704 if (!(local_file_list = send_file_list(-1,1,&name))) {
710 rprintf(FINFO,"deleting in %s\n", name);
712 for (i=local_file_list->count-1;i>=0;i--) {
713 if (!local_file_list->files[i]->basename) continue;
714 if (remote_version < 19 &&
715 S_ISDIR(local_file_list->files[i]->mode))
716 add_delete_entry(local_file_list->files[i]);
717 if (-1 == flist_find(flist,local_file_list->files[i])) {
718 delete_one(local_file_list->files[i]);
721 flist_free(local_file_list);
726 static char *cleanup_fname;
728 void exit_cleanup(int code)
732 do_unlink(cleanup_fname);
733 signal(SIGUSR1, SIG_IGN);
746 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
751 char fnametmp[MAXPATHLEN];
752 struct map_struct *buf;
754 struct file_struct *file;
759 rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
762 if (recurse && delete_mode && !local_name && flist->count>0) {
770 if (phase==0 && remote_version >= 13) {
772 csum_length = SUM_LENGTH;
774 rprintf(FINFO,"recv_files phase=%d\n",phase);
782 file = flist->files[i];
783 fname = f_name(file);
789 if (!am_server && verbose)
790 printf("%s\n",fname);
795 rprintf(FINFO,"recv_files(%s)\n",fname);
798 fd1 = open(fname,O_RDONLY);
800 if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
801 rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
802 receive_data(f_in,NULL,-1,NULL);
807 if (fd1 != -1 && !S_ISREG(st.st_mode)) {
808 rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
809 receive_data(f_in,NULL,-1,NULL);
814 if (fd1 != -1 && st.st_size > 0) {
815 buf = map_file(fd1,st.st_size);
817 rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
825 f = strrchr(fname,'/');
830 if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
831 rprintf(FERROR,"filename too long\n");
832 if (buf) unmap_file(buf);
836 slprintf(fnametmp,sizeof(fnametmp)-1, "%s/.%s.XXXXXX",tmpdir,f);
838 char *f = strrchr(fname,'/');
840 if (strlen(fname)+9 > MAXPATHLEN) {
841 rprintf(FERROR,"filename too long\n");
842 if (buf) unmap_file(buf);
849 slprintf(fnametmp,sizeof(fnametmp)-1,"%s/.%s.XXXXXX",fname,f+1);
852 slprintf(fnametmp,sizeof(fnametmp)-1,".%s.XXXXXX",fname);
855 if (NULL == do_mktemp(fnametmp)) {
856 rprintf(FERROR,"mktemp %s failed\n",fnametmp);
857 receive_data(f_in,buf,-1,NULL);
858 if (buf) unmap_file(buf);
862 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
863 if (fd2 == -1 && relative_paths && errno == ENOENT &&
864 create_directory_path(fnametmp) == 0) {
865 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
868 rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
869 receive_data(f_in,buf,-1,NULL);
870 if (buf) unmap_file(buf);
875 cleanup_fname = fnametmp;
877 if (!am_server && verbose)
878 printf("%s\n",fname);
881 recv_ok = receive_data(f_in,buf,fd2,fname);
883 if (buf) unmap_file(buf);
890 rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
893 char fnamebak[MAXPATHLEN];
894 if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
895 rprintf(FERROR,"backup filename too long\n");
898 slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
899 if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
900 rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
905 /* move tmp file over real file */
906 if (do_rename(fnametmp,fname) != 0) {
907 if (errno == EXDEV) {
908 /* rename failed on cross-filesystem link.
909 Copy the file instead. */
910 if (copy_file(fnametmp,fname, file->mode)) {
911 rprintf(FERROR,"copy %s -> %s : %s\n",
912 fnametmp,fname,strerror(errno));
914 set_perms(fname,file,NULL,0);
918 rprintf(FERROR,"rename %s -> %s : %s\n",
919 fnametmp,fname,strerror(errno));
923 set_perms(fname,file,NULL,0);
926 cleanup_fname = NULL;
930 if (csum_length == SUM_LENGTH) {
931 rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
935 rprintf(FINFO,"redoing %s(%d)\n",fname,i);
941 if (preserve_hard_links)
942 do_hard_links(flist);
944 /* now we need to fix any directory permissions that were
945 modified during the transfer */
946 for (i = 0; i < flist->count; i++) {
947 file = flist->files[i];
948 if (!file->basename || !S_ISDIR(file->mode)) continue;
949 recv_generator(f_name(file),flist,i,-1);
953 rprintf(FINFO,"recv_files finished\n");
960 void send_files(struct file_list *flist,int f_out,int f_in)
963 struct sum_struct *s;
964 struct map_struct *buf;
966 char fname[MAXPATHLEN];
968 struct file_struct *file;
973 rprintf(FINFO,"send_files starting\n");
975 setup_nonblocking(f_in,f_out);
980 if (phase==0 && remote_version >= 13) {
982 csum_length = SUM_LENGTH;
986 rprintf(FINFO,"send_files phase=%d\n",phase);
992 file = flist->files[i];
996 strlcpy(fname,file->basedir,MAXPATHLEN-1);
997 if (strlen(fname) == MAXPATHLEN-1) {
999 rprintf(FERROR, "send_files failed on long-named directory %s\n",
1003 strlcat(fname,"/",MAXPATHLEN-1);
1004 offset = strlen(file->basedir)+1;
1006 strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1009 rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1012 if (!am_server && verbose)
1013 printf("%s\n",fname);
1018 s = receive_sums(f_in);
1021 rprintf(FERROR,"receive_sums failed\n");
1025 fd = open(fname,O_RDONLY);
1028 rprintf(FERROR,"send_files failed to open %s: %s\n",
1029 fname,strerror(errno));
1034 /* map the local file */
1035 if (do_fstat(fd,&st) != 0) {
1037 rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1043 if (st.st_size > 0) {
1044 buf = map_file(fd,st.st_size);
1050 rprintf(FINFO,"send_files mapped %s of size %d\n",
1051 fname,(int)st.st_size);
1055 write_int(f_out,s->count);
1056 write_int(f_out,s->n);
1057 write_int(f_out,s->remainder);
1060 rprintf(FINFO,"calling match_sums %s\n",fname);
1062 if (!am_server && verbose)
1063 printf("%s\n",fname+offset);
1065 match_sums(f_out,s,buf,st.st_size);
1068 if (buf) unmap_file(buf);
1074 rprintf(FINFO,"sender finished %s\n",fname);
1078 rprintf(FINFO,"send files finished\n");
1082 write_int(f_out,-1);
1088 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1094 rprintf(FINFO,"generator starting pid=%d count=%d\n",
1095 (int)getpid(),flist->count);
1097 for (i = 0; i < flist->count; i++) {
1098 struct file_struct *file = flist->files[i];
1099 mode_t saved_mode = file->mode;
1100 if (!file->basename) continue;
1102 /* we need to ensure that any directories we create have writeable
1103 permissions initially so that we can create the files within
1104 them. This is then fixed after the files are transferred */
1105 if (!am_root && S_ISDIR(file->mode)) {
1106 file->mode |= S_IWUSR; /* user write */
1109 recv_generator(local_name?local_name:f_name(file),
1112 file->mode = saved_mode;
1116 csum_length = SUM_LENGTH;
1120 rprintf(FINFO,"generate_files phase=%d\n",phase);
1125 /* we expect to just sit around now, so don't exit on a timeout. If we
1126 really get a timeout then the other process should exit */
1129 if (remote_version >= 13) {
1130 /* in newer versions of the protocol the files can cycle through
1131 the system more than once to catch initial checksum errors */
1132 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1133 struct file_struct *file = flist->files[i];
1134 recv_generator(local_name?local_name:f_name(file),
1140 rprintf(FINFO,"generate_files phase=%d\n",phase);
1148 rprintf(FINFO,"generator wrote %ld\n",(long)write_total());