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);
154 generate a stream of signatures/checksums that describe a buffer
156 generate approximately one checksum every n bytes
158 static struct sum_struct *generate_sums(struct map_struct *buf,OFF_T len,int n)
161 struct sum_struct *s;
164 int remainder = (len%block_len);
167 count = (len+(block_len-1))/block_len;
169 s = (struct sum_struct *)malloc(sizeof(*s));
170 if (!s) out_of_memory("generate_sums");
173 s->remainder = remainder;
183 rprintf(FINFO,"count=%d rem=%d n=%d flength=%d\n",
184 s->count,s->remainder,s->n,(int)s->flength);
186 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
187 if (!s->sums) out_of_memory("generate_sums");
189 for (i=0;i<count;i++) {
191 char *map = map_ptr(buf,offset,n1);
193 s->sums[i].sum1 = get_checksum1(map,n1);
194 get_checksum2(map,n1,s->sums[i].sum2);
196 s->sums[i].offset = offset;
201 rprintf(FINFO,"chunk[%d] offset=%d len=%d sum1=%08x\n",
202 i,(int)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
213 receive the checksums for a buffer
215 static struct sum_struct *receive_sums(int f)
217 struct sum_struct *s;
221 s = (struct sum_struct *)malloc(sizeof(*s));
222 if (!s) out_of_memory("receive_sums");
224 s->count = read_int(f);
226 s->remainder = read_int(f);
230 rprintf(FINFO,"count=%d n=%d rem=%d\n",
231 s->count,s->n,s->remainder);
236 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
237 if (!s->sums) out_of_memory("receive_sums");
239 for (i=0;i<s->count;i++) {
240 s->sums[i].sum1 = read_int(f);
241 read_buf(f,s->sums[i].sum2,csum_length);
243 s->sums[i].offset = offset;
246 if (i == s->count-1 && s->remainder != 0) {
247 s->sums[i].len = s->remainder;
249 s->sums[i].len = s->n;
251 offset += s->sums[i].len;
254 rprintf(FINFO,"chunk[%d] len=%d offset=%d sum1=%08x\n",
255 i,s->sums[i].len,(int)s->sums[i].offset,s->sums[i].sum1);
264 static int set_perms(char *fname,struct file_struct *file,STRUCT_STAT *st,
269 extern int am_daemon;
271 if (dry_run) return 0;
274 if (link_stat(fname,&st2) != 0) {
275 rprintf(FERROR,"stat %s : %s\n",fname,strerror(errno));
281 if (preserve_times && !S_ISLNK(st->st_mode) &&
282 st->st_mtime != file->modtime) {
284 if (set_modtime(fname,file->modtime) != 0) {
285 rprintf(FERROR,"failed to set times on %s : %s\n",
286 fname,strerror(errno));
292 if (preserve_perms && !S_ISLNK(st->st_mode) &&
293 st->st_mode != file->mode) {
295 if (do_chmod(fname,file->mode) != 0) {
296 rprintf(FERROR,"failed to set permissions on %s : %s\n",
297 fname,strerror(errno));
303 if ((am_root || !am_daemon) &&
304 ((am_root && preserve_uid && st->st_uid != file->uid) ||
305 (preserve_gid && st->st_gid != file->gid))) {
307 (am_root&&preserve_uid)?file->uid:-1,
308 preserve_gid?file->gid:-1) != 0) {
309 if (preserve_uid && st->st_uid != file->uid)
311 if (verbose>1 || preserve_uid)
312 rprintf(FERROR,"chown %s : %s\n",
313 fname,strerror(errno));
319 if (verbose > 1 && report) {
321 rprintf(FINFO,"%s\n",fname);
323 rprintf(FINFO,"%s is uptodate\n",fname);
329 /* choose whether to skip a particular file */
330 static int skip_file(char *fname,
331 struct file_struct *file, STRUCT_STAT *st)
333 if (st->st_size != file->length) {
337 /* if always checksum is set then we use the checksum instead
338 of the file time to determine whether to sync */
339 if (always_checksum && S_ISREG(st->st_mode)) {
340 char sum[MD4_SUM_LENGTH];
341 file_checksum(fname,sum,st->st_size);
342 return (memcmp(sum,file->sum,csum_length) == 0);
349 return (st->st_mtime == file->modtime);
353 /* use a larger block size for really big files */
354 int adapt_block_size(struct file_struct *file, int bsize)
356 int ret = file->length / (10000); /* rough heuristic */
357 ret = ret & ~15; /* multiple of 16 */
358 if (ret < bsize) ret = bsize;
359 if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
363 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
367 struct map_struct *buf;
368 struct sum_struct *s;
370 struct file_struct *file = flist->files[i];
373 rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
375 statret = link_stat(fname,&st);
377 if (S_ISDIR(file->mode)) {
379 if (statret == 0 && !S_ISDIR(st.st_mode)) {
380 if (do_unlink(fname) != 0) {
381 rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
386 if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
387 if (!(relative_paths && errno==ENOENT &&
388 create_directory_path(fname)==0 &&
389 do_mkdir(fname,file->mode)==0)) {
390 rprintf(FERROR,"mkdir %s : %s (2)\n",
391 fname,strerror(errno));
394 if (set_perms(fname,file,NULL,0) && verbose)
395 rprintf(FINFO,"%s/\n",fname);
399 if (preserve_links && S_ISLNK(file->mode)) {
401 char lnk[MAXPATHLEN];
404 l = readlink(fname,lnk,MAXPATHLEN-1);
407 if (strcmp(lnk,file->link) == 0) {
408 set_perms(fname,file,&st,1);
414 if (do_symlink(file->link,fname) != 0) {
415 rprintf(FERROR,"link %s -> %s : %s\n",
416 fname,file->link,strerror(errno));
418 set_perms(fname,file,NULL,0);
420 rprintf(FINFO,"%s -> %s\n",
428 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
430 st.st_mode != file->mode ||
431 st.st_rdev != file->rdev) {
434 rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
435 fname,(int)file->mode,(int)file->rdev);
436 if (do_mknod(fname,file->mode,file->rdev) != 0) {
437 rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
439 set_perms(fname,file,NULL,0);
441 rprintf(FINFO,"%s\n",fname);
444 set_perms(fname,file,&st,1);
450 if (preserve_hard_links && check_hard_link(file)) {
452 rprintf(FINFO,"%s is a hard link\n",f_name(file));
456 if (!S_ISREG(file->mode)) {
457 rprintf(FINFO,"skipping non-regular file %s\n",fname);
462 if (errno == ENOENT) {
464 if (!dry_run) send_sums(NULL,f_out);
467 rprintf(FERROR,"recv_generator failed to open %s\n",fname);
472 if (!S_ISREG(st.st_mode)) {
473 if (delete_file(fname) != 0) {
477 /* now pretend the file didn't exist */
479 if (!dry_run) send_sums(NULL,f_out);
483 if (update_only && st.st_mtime > file->modtime) {
485 rprintf(FINFO,"%s is newer\n",fname);
489 if (skip_file(fname, file, &st)) {
490 set_perms(fname,file,&st,1);
501 send_sums(NULL,f_out);
506 fd = open(fname,O_RDONLY);
509 rprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
510 rprintf(FERROR,"skipping %s\n",fname);
514 if (st.st_size > 0) {
515 buf = map_file(fd,st.st_size);
521 rprintf(FINFO,"gen mapped %s of size %d\n",fname,(int)st.st_size);
523 s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
526 rprintf(FINFO,"sending sums for %d\n",i);
532 if (buf) unmap_file(buf);
539 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
541 int i,n,remainder,len,count;
545 static char file_sum1[MD4_SUM_LENGTH];
546 static char file_sum2[MD4_SUM_LENGTH];
549 count = read_int(f_in);
551 remainder = read_int(f_in);
555 for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
558 rprintf(FINFO,"data recv %d at %d\n",i,(int)offset);
562 if (fd != -1 && write_file(fd,data,i) != i) {
563 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
571 if (i == count-1 && remainder != 0)
575 rprintf(FINFO,"chunk[%d] of size %d at %d offset=%d\n",
576 i,len,(int)offset2,(int)offset);
578 map = map_ptr(buf,offset2,len);
583 if (fd != -1 && write_file(fd,map,len) != len) {
584 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
591 if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
592 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
598 if (remote_version >= 14) {
599 read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
601 rprintf(FINFO,"got file_sum\n");
602 if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
609 static void delete_one(struct file_struct *f)
611 if (!S_ISDIR(f->mode)) {
612 if (do_unlink(f_name(f)) != 0) {
613 rprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
614 } else if (verbose) {
615 rprintf(FINFO,"deleting %s\n",f_name(f));
618 if (do_rmdir(f_name(f)) != 0) {
619 if (errno != ENOTEMPTY && errno != EEXIST)
620 rprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
621 } else if (verbose) {
622 rprintf(FINFO,"deleting directory %s\n",f_name(f));
629 static struct delete_list {
633 static int dlist_len, dlist_alloc_len;
635 static void add_delete_entry(struct file_struct *file)
637 if (dlist_len == dlist_alloc_len) {
638 dlist_alloc_len += 1024;
640 delete_list = (struct delete_list *)malloc(sizeof(delete_list[0])*dlist_alloc_len);
642 delete_list = (struct delete_list *)realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
644 if (!delete_list) out_of_memory("add_delete_entry");
647 delete_list[dlist_len].dev = file->dev;
648 delete_list[dlist_len].inode = file->inode;
652 rprintf(FINFO,"added %s to delete list\n", f_name(file));
655 /* yuck! This function wouldn't have been necessary if I had the sorting
656 algorithm right. Unfortunately fixing the sorting algorithm would introduce
657 a backward incompatibility as file list indexes are sent over the link.
659 static int delete_already_done(struct file_list *flist,int j)
664 if (link_stat(f_name(flist->files[j]), &st)) return 1;
666 for (i=0;i<dlist_len;i++) {
667 if (st.st_ino == delete_list[i].inode &&
668 st.st_dev == delete_list[i].dev)
676 /* this deletes any files on the receiving side that are not present
677 on the sending side. For version 1.6.4 I have changed the behaviour
678 to match more closely what most people seem to expect of this option */
679 static void delete_files(struct file_list *flist)
681 struct file_list *local_file_list;
689 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
693 for (j=0;j<flist->count;j++) {
694 if (!S_ISDIR(flist->files[j]->mode) ||
695 !(flist->files[j]->flags & FLAG_DELETE)) continue;
697 if (remote_version < 19 &&
698 delete_already_done(flist, j)) continue;
700 name = strdup(f_name(flist->files[j]));
702 if (!(local_file_list = send_file_list(-1,1,&name))) {
708 rprintf(FINFO,"deleting in %s\n", name);
710 for (i=local_file_list->count-1;i>=0;i--) {
711 if (!local_file_list->files[i]->basename) continue;
712 if (remote_version < 19 &&
713 S_ISDIR(local_file_list->files[i]->mode))
714 add_delete_entry(local_file_list->files[i]);
715 if (-1 == flist_find(flist,local_file_list->files[i])) {
716 delete_one(local_file_list->files[i]);
719 flist_free(local_file_list);
724 static char *cleanup_fname;
726 void exit_cleanup(int code)
730 do_unlink(cleanup_fname);
731 signal(SIGUSR1, SIG_IGN);
744 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
749 char fnametmp[MAXPATHLEN];
750 struct map_struct *buf;
752 struct file_struct *file;
757 rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
760 if (recurse && delete_mode && !local_name && flist->count>0) {
768 if (phase==0 && remote_version >= 13) {
770 csum_length = SUM_LENGTH;
772 rprintf(FINFO,"recv_files phase=%d\n",phase);
779 file = flist->files[i];
780 fname = f_name(file);
786 if (!am_server && verbose)
787 printf("%s\n",fname);
792 rprintf(FINFO,"recv_files(%s)\n",fname);
795 fd1 = open(fname,O_RDONLY);
797 if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
798 rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
799 receive_data(f_in,NULL,-1,NULL);
804 if (fd1 != -1 && !S_ISREG(st.st_mode)) {
805 rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
806 receive_data(f_in,NULL,-1,NULL);
811 if (fd1 != -1 && st.st_size > 0) {
812 buf = map_file(fd1,st.st_size);
814 rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
822 f = strrchr(fname,'/');
827 if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
828 rprintf(FERROR,"filename too long\n");
829 if (buf) unmap_file(buf);
833 slprintf(fnametmp,sizeof(fnametmp)-1, "%s/.%s.XXXXXX",tmpdir,f);
835 char *f = strrchr(fname,'/');
837 if (strlen(fname)+9 > MAXPATHLEN) {
838 rprintf(FERROR,"filename too long\n");
839 if (buf) unmap_file(buf);
846 slprintf(fnametmp,sizeof(fnametmp)-1,"%s/.%s.XXXXXX",fname,f+1);
849 slprintf(fnametmp,sizeof(fnametmp)-1,".%s.XXXXXX",fname);
852 if (NULL == do_mktemp(fnametmp)) {
853 rprintf(FERROR,"mktemp %s failed\n",fnametmp);
854 receive_data(f_in,buf,-1,NULL);
855 if (buf) unmap_file(buf);
859 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
860 if (fd2 == -1 && relative_paths && errno == ENOENT &&
861 create_directory_path(fnametmp) == 0) {
862 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
865 rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
866 receive_data(f_in,buf,-1,NULL);
867 if (buf) unmap_file(buf);
872 cleanup_fname = fnametmp;
874 if (!am_server && verbose)
875 printf("%s\n",fname);
878 recv_ok = receive_data(f_in,buf,fd2,fname);
880 if (buf) unmap_file(buf);
887 rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
890 char fnamebak[MAXPATHLEN];
891 if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
892 rprintf(FERROR,"backup filename too long\n");
895 slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
896 if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
897 rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
902 /* move tmp file over real file */
903 if (do_rename(fnametmp,fname) != 0) {
904 if (errno == EXDEV) {
905 /* rename failed on cross-filesystem link.
906 Copy the file instead. */
907 if (copy_file(fnametmp,fname, file->mode)) {
908 rprintf(FERROR,"copy %s -> %s : %s\n",
909 fnametmp,fname,strerror(errno));
911 set_perms(fname,file,NULL,0);
915 rprintf(FERROR,"rename %s -> %s : %s\n",
916 fnametmp,fname,strerror(errno));
920 set_perms(fname,file,NULL,0);
923 cleanup_fname = NULL;
927 if (csum_length == SUM_LENGTH) {
928 rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
932 rprintf(FINFO,"redoing %s(%d)\n",fname,i);
938 if (preserve_hard_links)
939 do_hard_links(flist);
941 /* now we need to fix any directory permissions that were
942 modified during the transfer */
943 for (i = 0; i < flist->count; i++) {
944 file = flist->files[i];
945 if (!file->basename || !S_ISDIR(file->mode)) continue;
946 recv_generator(f_name(file),flist,i,-1);
950 rprintf(FINFO,"recv_files finished\n");
957 void send_files(struct file_list *flist,int f_out,int f_in)
960 struct sum_struct *s;
961 struct map_struct *buf;
963 char fname[MAXPATHLEN];
965 struct file_struct *file;
970 rprintf(FINFO,"send_files starting\n");
972 setup_readbuffer(f_in);
977 if (phase==0 && remote_version >= 13) {
979 csum_length = SUM_LENGTH;
982 rprintf(FINFO,"send_files phase=%d\n",phase);
988 file = flist->files[i];
992 strlcpy(fname,file->basedir,MAXPATHLEN-1);
993 if (strlen(fname) == MAXPATHLEN-1) {
995 rprintf(FERROR, "send_files failed on long-named directory %s\n",
999 strlcat(fname,"/",MAXPATHLEN-1);
1000 offset = strlen(file->basedir)+1;
1002 strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1005 rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1008 if (!am_server && verbose)
1009 printf("%s\n",fname);
1014 s = receive_sums(f_in);
1017 rprintf(FERROR,"receive_sums failed\n");
1021 fd = open(fname,O_RDONLY);
1024 rprintf(FERROR,"send_files failed to open %s: %s\n",
1025 fname,strerror(errno));
1030 /* map the local file */
1031 if (do_fstat(fd,&st) != 0) {
1033 rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1039 if (st.st_size > 0) {
1040 buf = map_file(fd,st.st_size);
1046 rprintf(FINFO,"send_files mapped %s of size %d\n",
1047 fname,(int)st.st_size);
1051 write_int(f_out,s->count);
1052 write_int(f_out,s->n);
1053 write_int(f_out,s->remainder);
1056 rprintf(FINFO,"calling match_sums %s\n",fname);
1058 if (!am_server && verbose)
1059 printf("%s\n",fname+offset);
1061 match_sums(f_out,s,buf,st.st_size);
1063 if (buf) unmap_file(buf);
1069 rprintf(FINFO,"sender finished %s\n",fname);
1073 rprintf(FINFO,"send files finished\n");
1077 write_int(f_out,-1);
1082 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1088 rprintf(FINFO,"generator starting pid=%d count=%d\n",
1089 (int)getpid(),flist->count);
1091 for (i = 0; i < flist->count; i++) {
1092 struct file_struct *file = flist->files[i];
1093 mode_t saved_mode = file->mode;
1094 if (!file->basename) continue;
1096 /* we need to ensure that any directories we create have writeable
1097 permissions initially so that we can create the files within
1098 them. This is then fixed after the files are transferred */
1099 if (!am_root && S_ISDIR(file->mode)) {
1100 file->mode |= S_IWUSR; /* user write */
1103 recv_generator(local_name?local_name:f_name(file),
1106 file->mode = saved_mode;
1110 csum_length = SUM_LENGTH;
1114 rprintf(FINFO,"generate_files phase=%d\n",phase);
1118 /* we expect to just sit around now, so don't exit on a timeout. If we
1119 really get a timeout then the other process should exit */
1122 if (remote_version >= 13) {
1123 /* in newer versions of the protocol the files can cycle through
1124 the system more than once to catch initial checksum errors */
1125 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1126 struct file_struct *file = flist->files[i];
1127 recv_generator(local_name?local_name:f_name(file),
1133 rprintf(FINFO,"generate_files phase=%d\n",phase);
1140 rprintf(FINFO,"generator wrote %ld\n",(long)write_total());