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 (delete_already_done(flist, j)) continue;
701 name = strdup(f_name(flist->files[j]));
703 if (!(local_file_list = send_file_list(-1,1,&name))) {
709 rprintf(FINFO,"deleting in %s\n", name);
711 for (i=local_file_list->count-1;i>=0;i--) {
712 if (!local_file_list->files[i]->basename) continue;
713 if (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);
780 file = flist->files[i];
781 fname = f_name(file);
787 if (!am_server && verbose)
788 printf("%s\n",fname);
793 rprintf(FINFO,"recv_files(%s)\n",fname);
796 fd1 = open(fname,O_RDONLY);
798 if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
799 rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
800 receive_data(f_in,NULL,-1,NULL);
805 if (fd1 != -1 && !S_ISREG(st.st_mode)) {
806 rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
807 receive_data(f_in,NULL,-1,NULL);
812 if (fd1 != -1 && st.st_size > 0) {
813 buf = map_file(fd1,st.st_size);
815 rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
823 f = strrchr(fname,'/');
828 if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
829 rprintf(FERROR,"filename too long\n");
830 if (buf) unmap_file(buf);
834 slprintf(fnametmp,sizeof(fnametmp)-1, "%s/.%s.XXXXXX",tmpdir,f);
836 char *f = strrchr(fname,'/');
838 if (strlen(fname)+9 > MAXPATHLEN) {
839 rprintf(FERROR,"filename too long\n");
840 if (buf) unmap_file(buf);
847 slprintf(fnametmp,sizeof(fnametmp)-1,"%s/.%s.XXXXXX",fname,f+1);
850 slprintf(fnametmp,sizeof(fnametmp)-1,".%s.XXXXXX",fname);
853 if (NULL == do_mktemp(fnametmp)) {
854 rprintf(FERROR,"mktemp %s failed\n",fnametmp);
855 receive_data(f_in,buf,-1,NULL);
856 if (buf) unmap_file(buf);
860 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
861 if (fd2 == -1 && relative_paths && errno == ENOENT &&
862 create_directory_path(fnametmp) == 0) {
863 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
866 rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
867 receive_data(f_in,buf,-1,NULL);
868 if (buf) unmap_file(buf);
873 cleanup_fname = fnametmp;
875 if (!am_server && verbose)
876 printf("%s\n",fname);
879 recv_ok = receive_data(f_in,buf,fd2,fname);
881 if (buf) unmap_file(buf);
888 rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
891 char fnamebak[MAXPATHLEN];
892 if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
893 rprintf(FERROR,"backup filename too long\n");
896 slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
897 if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
898 rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
903 /* move tmp file over real file */
904 if (do_rename(fnametmp,fname) != 0) {
905 if (errno == EXDEV) {
906 /* rename failed on cross-filesystem link.
907 Copy the file instead. */
908 if (copy_file(fnametmp,fname, file->mode)) {
909 rprintf(FERROR,"copy %s -> %s : %s\n",
910 fnametmp,fname,strerror(errno));
912 set_perms(fname,file,NULL,0);
916 rprintf(FERROR,"rename %s -> %s : %s\n",
917 fnametmp,fname,strerror(errno));
921 set_perms(fname,file,NULL,0);
924 cleanup_fname = NULL;
928 if (csum_length == SUM_LENGTH) {
929 rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
933 rprintf(FINFO,"redoing %s(%d)\n",fname,i);
939 if (preserve_hard_links)
940 do_hard_links(flist);
942 /* now we need to fix any directory permissions that were
943 modified during the transfer */
944 for (i = 0; i < flist->count; i++) {
945 file = flist->files[i];
946 if (!file->basename || !S_ISDIR(file->mode)) continue;
947 recv_generator(f_name(file),flist,i,-1);
951 rprintf(FINFO,"recv_files finished\n");
958 void send_files(struct file_list *flist,int f_out,int f_in)
961 struct sum_struct *s;
962 struct map_struct *buf;
964 char fname[MAXPATHLEN];
966 struct file_struct *file;
971 rprintf(FINFO,"send_files starting\n");
973 setup_nonblocking(f_in,f_out);
978 if (phase==0 && remote_version >= 13) {
980 csum_length = SUM_LENGTH;
984 rprintf(FINFO,"send_files phase=%d\n",phase);
990 file = flist->files[i];
994 strlcpy(fname,file->basedir,MAXPATHLEN-1);
995 if (strlen(fname) == MAXPATHLEN-1) {
997 rprintf(FERROR, "send_files failed on long-named directory %s\n",
1001 strlcat(fname,"/",MAXPATHLEN-1);
1002 offset = strlen(file->basedir)+1;
1004 strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1007 rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1010 if (!am_server && verbose)
1011 printf("%s\n",fname);
1016 s = receive_sums(f_in);
1019 rprintf(FERROR,"receive_sums failed\n");
1023 fd = open(fname,O_RDONLY);
1026 rprintf(FERROR,"send_files failed to open %s: %s\n",
1027 fname,strerror(errno));
1032 /* map the local file */
1033 if (do_fstat(fd,&st) != 0) {
1035 rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1041 if (st.st_size > 0) {
1042 buf = map_file(fd,st.st_size);
1048 rprintf(FINFO,"send_files mapped %s of size %d\n",
1049 fname,(int)st.st_size);
1053 write_int(f_out,s->count);
1054 write_int(f_out,s->n);
1055 write_int(f_out,s->remainder);
1058 rprintf(FINFO,"calling match_sums %s\n",fname);
1060 if (!am_server && verbose)
1061 printf("%s\n",fname+offset);
1063 match_sums(f_out,s,buf,st.st_size);
1066 if (buf) unmap_file(buf);
1072 rprintf(FINFO,"sender finished %s\n",fname);
1076 rprintf(FINFO,"send files finished\n");
1080 write_int(f_out,-1);
1086 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1092 rprintf(FINFO,"generator starting pid=%d count=%d\n",
1093 (int)getpid(),flist->count);
1095 for (i = 0; i < flist->count; i++) {
1096 struct file_struct *file = flist->files[i];
1097 mode_t saved_mode = file->mode;
1098 if (!file->basename) continue;
1100 /* we need to ensure that any directories we create have writeable
1101 permissions initially so that we can create the files within
1102 them. This is then fixed after the files are transferred */
1103 if (!am_root && S_ISDIR(file->mode)) {
1104 file->mode |= S_IWUSR; /* user write */
1107 recv_generator(local_name?local_name:f_name(file),
1110 file->mode = saved_mode;
1114 csum_length = SUM_LENGTH;
1118 rprintf(FINFO,"generate_files phase=%d\n",phase);
1123 /* we expect to just sit around now, so don't exit on a timeout. If we
1124 really get a timeout then the other process should exit */
1127 if (remote_version >= 13) {
1128 /* in newer versions of the protocol the files can cycle through
1129 the system more than once to catch initial checksum errors */
1130 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1131 struct file_struct *file = flist->files[i];
1132 recv_generator(local_name?local_name:f_name(file),
1138 rprintf(FINFO,"generate_files phase=%d\n",phase);
1146 rprintf(FINFO,"generator wrote %ld\n",(long)write_total());