[packages/elinks.git] / elinks-decompress4.patch

--- elinks/src/protocol/http/http.c	Sun Dec 22 12:52:20 2002
+++ elinks.2/src/protocol/http/http.c	Tue Dec 24 22:15:59 2002
@@ -665,16 +665,14 @@
 	/* Number of uncompressed bytes that could be safely get from
 	 * read_encoded().  We can't want to read too much, because if gzread
 	 * "clears" the buffer next time it will return -1. */
-	int ret = 0;
+	int ret = 2048;
 	int r = 0, *length_of_block;
-	/* If true, all stuff was written to pipe and only uncompression is
-	 * wanted now. */
-	int finishing = 0;
 	unsigned char *output = NULL;
 
 	length_of_block = (info->length == LEN_CHUNKED ? &info->chunk_remaining
 						       : &info->length);
-	if (!*length_of_block) finishing = 1;
+	if (!*length_of_block)
+		ret = 65536;
 
 	if (conn->content_encoding == ENCODING_NONE) {
 		*new_len = len;
@@ -690,9 +688,9 @@
 		|| set_nonblocking_fd(conn->stream_pipes[1]) < 0))
 		return NULL;
 
-	while (r == ret) {
-		if (!finishing) {
-			int written = write(conn->stream_pipes[1], data, len);
+	do {
+		if (ret == 2048) {
+			int written = write(conn->stream_pipes[1], data, len > ret ? ret : len);
 
 			/* When we're writing zero bytes already, we want to
 			 * zero ret properly for now, so that we'll go out for
@@ -700,37 +698,16 @@
 			 * zero bytes, but ret will be on its original value,
 			 * causing us to close the stream, and that's disaster
 			 * when more data are about to come yet. */
-			if (written > 0 || (!written && !len)) {
-				ret = written;
-				data += ret;
-				len -= ret;
+			if (written > 0) {
+				data += written;
+				len -= written;
 				if (*length_of_block > 0)
-					*length_of_block -= ret;
+					*length_of_block -= written;
 				if (!info->length)
-					finishing = 1;
+					ret = 65536;
+				else if (!len)
+					return output;
 			}
-
-			if (len) {
-				/* We assume that this is because full pipe. */
-				/* FIXME: We should probably handle errors as
-				 * well. --pasky */
-				ret = 4096; /* pipe capacity */
-			}
-		}
-		/* finishing could be changed above ;) */
-		if (finishing) {
-			/* Granularity of the final decompression. When we were
-			 * taking the decompressed content, we only took the
-			 * amount which we inserted there. When finishing, we
-			 * have to drain the rest from the beast. */
-			/* TODO: We should probably double the ret before trying
-			 * to read as well..? Would maybe make the progressive
-			 * displaying feeling better? --pasky */
-			ret = 65536;
-		}
-		if (ret < 4096) {
-			/* Not enough data, try in next round. */
-			return output;
 		}
 
 		if (!conn->stream) {
@@ -743,8 +720,9 @@
 		if (!output) break;
 
 		r = read_encoded(conn->stream, output + *new_len, ret);
+		
 		if (r > 0) *new_len += r;
-	}
+	} while (len || r == ret);
 
 	if (r < 0 && output) {
 		mem_free(output);
Commit	Line	Data
	1	--- elinks/src/protocol/http/http.c Sun Dec 22 12:52:20 2002
	2	+++ elinks.2/src/protocol/http/http.c Tue Dec 24 22:15:59 2002
	3	@@ -665,16 +665,14 @@
	4	/* Number of uncompressed bytes that could be safely get from
	5	* read_encoded(). We can't want to read too much, because if gzread
	6	* "clears" the buffer next time it will return -1. */
	7	- int ret = 0;
	8	+ int ret = 2048;
	9	int r = 0, *length_of_block;
	10	- /* If true, all stuff was written to pipe and only uncompression is
	11	- * wanted now. */
	12	- int finishing = 0;
	13	unsigned char *output = NULL;
	14
	15	length_of_block = (info->length == LEN_CHUNKED ? &info->chunk_remaining
	16	: &info->length);
	17	- if (!*length_of_block) finishing = 1;
	18	+ if (!*length_of_block)
	19	+ ret = 65536;
	20
	21	if (conn->content_encoding == ENCODING_NONE) {
	22	*new_len = len;
	23	@@ -690,9 +688,9 @@
	24	\|\| set_nonblocking_fd(conn->stream_pipes[1]) < 0))
	25	return NULL;
	26
	27	- while (r == ret) {
	28	- if (!finishing) {
	29	- int written = write(conn->stream_pipes[1], data, len);
	30	+ do {
	31	+ if (ret == 2048) {
	32	+ int written = write(conn->stream_pipes[1], data, len > ret ? ret : len);
	33
	34	/* When we're writing zero bytes already, we want to
	35	* zero ret properly for now, so that we'll go out for
	36	@@ -700,37 +698,16 @@
	37	* zero bytes, but ret will be on its original value,
	38	* causing us to close the stream, and that's disaster
	39	* when more data are about to come yet. */
	40	- if (written > 0 \|\| (!written && !len)) {
	41	- ret = written;
	42	- data += ret;
	43	- len -= ret;
	44	+ if (written > 0) {
	45	+ data += written;
	46	+ len -= written;
	47	if (*length_of_block > 0)
	48	- *length_of_block -= ret;
	49	+ *length_of_block -= written;
	50	if (!info->length)
	51	- finishing = 1;
	52	+ ret = 65536;
	53	+ else if (!len)
	54	+ return output;
	55	}
	56	-
	57	- if (len) {
	58	- /* We assume that this is because full pipe. */
	59	- /* FIXME: We should probably handle errors as
	60	- * well. --pasky */
	61	- ret = 4096; /* pipe capacity */
	62	- }
	63	- }
	64	- /* finishing could be changed above ;) */
	65	- if (finishing) {
	66	- /* Granularity of the final decompression. When we were
	67	- * taking the decompressed content, we only took the
	68	- * amount which we inserted there. When finishing, we
	69	- * have to drain the rest from the beast. */
	70	- /* TODO: We should probably double the ret before trying
	71	- * to read as well..? Would maybe make the progressive
	72	- * displaying feeling better? --pasky */
	73	- ret = 65536;
	74	- }
	75	- if (ret < 4096) {
	76	- /* Not enough data, try in next round. */
	77	- return output;
	78	}
	79
	80	if (!conn->stream) {
	81	@@ -743,8 +720,9 @@
	82	if (!output) break;
	83
	84	r = read_encoded(conn->stream, output + *new_len, ret);
	85	+
	86	if (r > 0) *new_len += r;
	87	- }
	88	+ } while (len \|\| r == ret);
	89
	90	if (r < 0 && output) {
	91	mem_free(output);