===================================================================
RCS file: /cvsrepo/anoncvs/cvs/src/usr.bin/rsync/downloader.c,v
retrieving revision 1.3
retrieving revision 1.4
diff -c -r1.3 -r1.4
*** src/usr.bin/rsync/downloader.c	2019/02/11 19:18:36	1.3
--- src/usr.bin/rsync/downloader.c	2019/02/11 21:41:22	1.4
***************
*** 1,4 ****
! /*	$Id: downloader.c,v 1.3 2019/02/11 19:18:36 deraadt Exp $ */
  /*
   * Copyright (c) 2019 Kristaps Dzonsons <kristaps@bsd.lv>
   *
--- 1,4 ----
! /*	$Id: downloader.c,v 1.4 2019/02/11 21:41:22 deraadt Exp $ */
  /*
   * Copyright (c) 2019 Kristaps Dzonsons <kristaps@bsd.lv>
   *
***************
*** 116,122 ****
  {
  	int32_t seed = htole32(sess->seed);
  
! 	assert(DOWNLOAD_READ_NEXT == p->state);
  
  	p->idx = idx;
  	memset(&p->blk, 0, sizeof(struct blkset));
--- 116,122 ----
  {
  	int32_t seed = htole32(sess->seed);
  
! 	assert(p->state == DOWNLOAD_READ_NEXT);
  
  	p->idx = idx;
  	memset(&p->blk, 0, sizeof(struct blkset));
***************
*** 143,161 ****
  download_cleanup(struct download *p, int cleanup)
  {
  
! 	if (MAP_FAILED != p->map) {
  		assert(p->mapsz);
  		munmap(p->map, p->mapsz);
  		p->map = MAP_FAILED;
  		p->mapsz = 0;
  	}
! 	if (-1 != p->ofd) {
  		close(p->ofd);
  		p->ofd = -1;
  	}
! 	if (-1 != p->fd) {
  		close(p->fd);
! 		if (cleanup && NULL != p->fname)
  			unlinkat(p->rootfd, p->fname, 0);
  		p->fd = -1;
  	}
--- 143,161 ----
  download_cleanup(struct download *p, int cleanup)
  {
  
! 	if (p->map != MAP_FAILED) {
  		assert(p->mapsz);
  		munmap(p->map, p->mapsz);
  		p->map = MAP_FAILED;
  		p->mapsz = 0;
  	}
! 	if (p->ofd != -1) {
  		close(p->ofd);
  		p->ofd = -1;
  	}
! 	if (p->fd != -1) {
  		close(p->fd);
! 		if (cleanup && p->fname != NULL)
  			unlinkat(p->rootfd, p->fname, 0);
  		p->fd = -1;
  	}
***************
*** 176,182 ****
  {
  	struct download	*p;
  
! 	if (NULL == (p = malloc(sizeof(struct download)))) {
  		ERR(sess, "malloc");
  		return NULL;
  	}
--- 176,182 ----
  {
  	struct download	*p;
  
! 	if ((p = malloc(sizeof(struct download))) == NULL) {
  		ERR(sess, "malloc");
  		return NULL;
  	}
***************
*** 190,197 ****
  	p->obufsz = 0;
  	p->obuf = NULL;
  	p->obufmax = OBUF_SIZE;
! 	if (p->obufmax &&
! 	    NULL == (p->obuf = malloc(p->obufmax))) {
  		ERR(sess, "malloc");
  		free(p);
  		return NULL;
--- 190,196 ----
  	p->obufsz = 0;
  	p->obuf = NULL;
  	p->obufmax = OBUF_SIZE;
! 	if (p->obufmax && (p->obuf = malloc(p->obufmax)) == NULL) {
  		ERR(sess, "malloc");
  		free(p);
  		return NULL;
***************
*** 207,213 ****
  download_free(struct download *p)
  {
  
! 	if (NULL == p)
  		return;
  	download_cleanup(p, 1);
  	free(p->obuf);
--- 206,212 ----
  download_free(struct download *p)
  {
  
! 	if (p == NULL)
  		return;
  	download_cleanup(p, 1);
  	free(p->obuf);
***************
*** 239,245 ****
  	 */
  
  	if (sz && p->obufsz < p->obufmax) {
! 		assert(NULL != p->obuf);
  		rem = p->obufmax - p->obufsz;
  		assert(rem > 0);
  		tocopy = rem < sz ? rem : sz;
--- 238,244 ----
  	 */
  
  	if (sz && p->obufsz < p->obufmax) {
! 		assert(p->obuf != NULL);
  		rem = p->obufmax - p->obufsz;
  		assert(rem > 0);
  		tocopy = rem < sz ? rem : sz;
***************
*** 248,254 ****
  		buf += tocopy;
  		p->obufsz += tocopy;
  		assert(p->obufsz <= p->obufmax);
! 		if (0 == sz)
  			return 1;
  	}
  
--- 247,253 ----
  		buf += tocopy;
  		p->obufsz += tocopy;
  		assert(p->obufsz <= p->obufmax);
! 		if (sz == 0)
  			return 1;
  	}
  
***************
*** 257,263 ****
  	if (p->obufsz) {
  		assert(p->obufmax);
  		assert(p->obufsz <= p->obufmax);
! 		assert(NULL != p->obuf);
  		if ((ssz = write(p->fd, p->obuf, p->obufsz)) < 0) {
  			ERR(sess, "%s: write", p->fname);
  			return 0;
--- 256,262 ----
  	if (p->obufsz) {
  		assert(p->obufmax);
  		assert(p->obufsz <= p->obufmax);
! 		assert(p->obuf != NULL);
  		if ((ssz = write(p->fd, p->obuf, p->obufsz)) < 0) {
  			ERR(sess, "%s: write", p->fname);
  			return 0;
***************
*** 315,321 ****
  	 * metadata, in which case we open our file and wait for data.
  	 */
  
! 	if (DOWNLOAD_READ_NEXT == p->state) {
  		if (!io_read_int(sess, p->fdin, &idx)) {
  			ERRX1(sess, "io_read_int");
  			return -1;
--- 314,320 ----
  	 * metadata, in which case we open our file and wait for data.
  	 */
  
! 	if (p->state == DOWNLOAD_READ_NEXT) {
  		if (!io_read_int(sess, p->fdin, &idx)) {
  			ERRX1(sess, "io_read_int");
  			return -1;
***************
*** 355,367 ****
  
  		p->state = DOWNLOAD_READ_LOCAL;
  		f = &p->fl[idx];
! 		p->ofd = openat(p->rootfd, f->path,
! 			O_RDONLY | O_NONBLOCK, 0);
  
! 		if (-1 == p->ofd && ENOENT != errno) {
  			ERR(sess, "%s: openat", f->path);
  			goto out;
! 		} else if (-1 != p->ofd) {
  			*ofd = p->ofd;
  			return 1;
  		}
--- 354,365 ----
  
  		p->state = DOWNLOAD_READ_LOCAL;
  		f = &p->fl[idx];
! 		p->ofd = openat(p->rootfd, f->path, O_RDONLY | O_NONBLOCK, 0);
  
! 		if (p->ofd == -1 && errno != ENOENT) {
  			ERR(sess, "%s: openat", f->path);
  			goto out;
! 		} else if (p->ofd != -1) {
  			*ofd = p->ofd;
  			return 1;
  		}
***************
*** 385,392 ****
  	 * original file in a nonblocking way, and we can map it.
  	 */
  
! 	if (DOWNLOAD_READ_LOCAL == p->state) {
! 		assert(NULL == p->fname);
  
  		/*
  		 * Try to fstat() the file descriptor if valid and make
--- 383,390 ----
  	 * original file in a nonblocking way, and we can map it.
  	 */
  
! 	if (p->state == DOWNLOAD_READ_LOCAL) {
! 		assert(p->fname == NULL);
  
  		/*
  		 * Try to fstat() the file descriptor if valid and make
***************
*** 394,413 ****
  		 * Then, if it has non-zero size, mmap() it for hashing.
  		 */
  
! 		if (-1 != p->ofd &&
! 		    -1 == fstat(p->ofd, &st)) {
  			ERR(sess, "%s: fstat", f->path);
  			goto out;
! 		} else if (-1 != p->ofd && !S_ISREG(st.st_mode)) {
  			WARNX(sess, "%s: not regular", f->path);
  			goto out;
  		}
  
! 		if (-1 != p->ofd && st.st_size > 0) {
  			p->mapsz = st.st_size;
  			p->map = mmap(NULL, p->mapsz,
  				PROT_READ, MAP_SHARED, p->ofd, 0);
! 			if (MAP_FAILED == p->map) {
  				ERR(sess, "%s: mmap", f->path);
  				goto out;
  			}
--- 392,411 ----
  		 * Then, if it has non-zero size, mmap() it for hashing.
  		 */
  
! 		if (p->ofd != -1 &&
! 		    fstat(p->ofd, &st) == -1) {
  			ERR(sess, "%s: fstat", f->path);
  			goto out;
! 		} else if (p->ofd != -1 && !S_ISREG(st.st_mode)) {
  			WARNX(sess, "%s: not regular", f->path);
  			goto out;
  		}
  
! 		if (p->ofd != -1 && st.st_size > 0) {
  			p->mapsz = st.st_size;
  			p->map = mmap(NULL, p->mapsz,
  				PROT_READ, MAP_SHARED, p->ofd, 0);
! 			if (p->map == MAP_FAILED) {
  				ERR(sess, "%s: mmap", f->path);
  				goto out;
  			}
***************
*** 438,444 ****
  			    f->path, hash) < 0)
  				p->fname = NULL;
  		}
! 		if (NULL == p->fname) {
  			ERR(sess, "asprintf");
  			goto out;
  		}
--- 436,442 ----
  			    f->path, hash) < 0)
  				p->fname = NULL;
  		}
! 		if (p->fname == NULL) {
  			ERR(sess, "asprintf");
  			goto out;
  		}
***************
*** 456,462 ****
  		p->fd = openat(p->rootfd, p->fname,
  			O_APPEND|O_WRONLY|O_CREAT|O_EXCL, perm);
  
! 		if (-1 == p->fd) {
  			ERR(sess, "%s: openat", p->fname);
  			goto out;
  		}
--- 454,460 ----
  		p->fd = openat(p->rootfd, p->fname,
  			O_APPEND|O_WRONLY|O_CREAT|O_EXCL, perm);
  
! 		if (p->fd == -1) {
  			ERR(sess, "%s: openat", p->fname);
  			goto out;
  		}
***************
*** 483,492 ****
  	 * a token indicator.
  	 */
  
! 	assert(DOWNLOAD_READ_REMOTE == p->state);
! 	assert(NULL != p->fname);
! 	assert(-1 != p->fd);
! 	assert(-1 != p->fdin);
  
  	if (!io_read_int(sess, p->fdin, &rawtok)) {
  		ERRX1(sess, "io_read_int");
--- 481,490 ----
  	 * a token indicator.
  	 */
  
! 	assert(p->state == DOWNLOAD_READ_REMOTE);
! 	assert(p->fname != NULL);
! 	assert(p->fd != -1);
! 	assert(p->fdin != -1);
  
  	if (!io_read_int(sess, p->fdin, &rawtok)) {
  		ERRX1(sess, "io_read_int");
***************
*** 495,501 ****
  
  	if (rawtok > 0) {
  		sz = rawtok;
! 		if (NULL == (buf = malloc(sz))) {
  			ERR(sess, "realloc");
  			goto out;
  		}
--- 493,499 ----
  
  	if (rawtok > 0) {
  		sz = rawtok;
! 		if ((buf = malloc(sz)) == NULL) {
  			ERR(sess, "realloc");
  			goto out;
  		}
***************
*** 522,528 ****
  		}
  		sz = tok == p->blk.blksz - 1 ? p->blk.rem : p->blk.len;
  		assert(sz);
! 		assert(MAP_FAILED != p->map);
  		buf = p->map + (tok * p->blk.len);
  
  		/*
--- 520,526 ----
  		}
  		sz = tok == p->blk.blksz - 1 ? p->blk.rem : p->blk.len;
  		assert(sz);
! 		assert(p->map != MAP_FAILED);
  		buf = p->map + (tok * p->blk.len);
  
  		/*
***************
*** 533,539 ****
  		 * profile from it.
  		 */
  
! 		assert(MAP_FAILED != p->map);
  		if (!buf_copy(sess, buf, sz, p)) {
  			ERRX1(sess, "buf_copy");
  			goto out;
--- 531,537 ----
  		 * profile from it.
  		 */
  
! 		assert(p->map != MAP_FAILED);
  		if (!buf_copy(sess, buf, sz, p)) {
  			ERRX1(sess, "buf_copy");
  			goto out;
***************
*** 549,556 ****
  		goto out;
  	}
  
! 	assert(0 == rawtok);
! 	assert(0 == p->obufsz);
  
  	/*
  	 * Make sure our resulting MD4 hashes match.
--- 547,554 ----
  		goto out;
  	}
  
! 	assert(rawtok == 0);
! 	assert(p->obufsz == 0);
  
  	/*
  	 * Make sure our resulting MD4 hashes match.
***************
*** 577,583 ****
  		tv[0].tv_nsec = 0;
  		tv[1].tv_sec = f->st.mtime;
  		tv[1].tv_nsec = 0;
! 		if (-1 == futimens(p->fd, tv)) {
  			ERR(sess, "%s: futimens", p->fname);
  			goto out;
  		}
--- 575,581 ----
  		tv[0].tv_nsec = 0;
  		tv[1].tv_sec = f->st.mtime;
  		tv[1].tv_nsec = 0;
! 		if (futimens(p->fd, tv) == -1) {
  			ERR(sess, "%s: futimens", p->fname);
  			goto out;
  		}
***************
*** 586,592 ****
  
  	/* Finally, rename the temporary to the real file. */
  
! 	if (-1 == renameat(p->rootfd, p->fname, p->rootfd, f->path)) {
  		ERR(sess, "%s: renameat: %s", p->fname, f->path);
  		goto out;
  	}
--- 584,590 ----
  
  	/* Finally, rename the temporary to the real file. */
  
! 	if (renameat(p->rootfd, p->fname, p->rootfd, f->path) == -1) {
  		ERR(sess, "%s: renameat: %s", p->fname, f->path);
  		goto out;
  	}