dist/libarchive/archive_read.c

161  * Set read options for the filter.
167 	struct archive_read_filter *filter;
181 	for (filter = a->filter; filter != NULL; filter = filter->upstream) {
182 		bidder = filter->bidder;
188 		while ((len = __archive_parse_options(s, filter->name,
208  * Set read options for the format and the filter.
298 	struct archive_read_filter *filter;
325 	filter = calloc(1, sizeof(*filter));
326 	if (filter == NULL)
328 	filter->bidder = NULL;
329 	filter->upstream = NULL;
330 	filter->archive = a;
331 	filter->data = client_data;
332 	filter->read = client_read_proxy;
333 	filter->skip = client_skip_proxy;
334 	filter->close = client_close_proxy;
335 	filter->name = "none";
336 	filter->code = ARCHIVE_COMPRESSION_NONE;
337 	a->filter = filter;
357 	struct archive_read_filter *filter;
370 				bid = (bidder->bid)(bidder, a->filter);
380 			a->archive.compression_name = a->filter->name;
381 			a->archive.compression_code = a->filter->code;
385 		filter
386 		    = (struct archive_read_filter *)calloc(1, sizeof(*filter));
387 		if (filter == NULL)
389 		filter->bidder = best_bidder;
390 		filter->archive = a;
391 		filter->upstream = a->filter;
392 		r = (best_bidder->init)(filter);
394 			free(filter);
397 		a->filter = filter;
398 		/* Verify the filter by asking it for some data. */
399 		__archive_read_filter_ahead(filter, 1, &avail);
741 	/* Release the filter objects. */
763 	/* Clean up the filter pipeline. */
764 	while (a->filter != NULL) {
765 		struct archive_read_filter *t = a->filter->upstream;
766 		if (a->filter->close != NULL) {
767 			int r1 = (a->filter->close)(a->filter);
771 		free(a->filter->buffer);
772 		free(a->filter);
773 		a->filter = t;
952 	return (__archive_read_filter_ahead(a->filter, min, avail));
956 __archive_read_filter_ahead(struct archive_read_filter *filter,
962 	if (filter->fatal) {
979 		if (filter->avail >= min && filter->avail > 0) {
981 				*avail = filter->avail;
982 			return (filter->next);
989 		if (filter->client_total >= filter->client_avail + filter->avail
990 		    && filter->client_avail + filter->avail >= min) {
992 			filter->client_avail += filter->avail;
993 			filter->client_next -= filter->avail;
995 			filter->avail = 0;
996 			filter->next = filter->buffer;
999 				*avail = filter->client_avail;
1000 			return (filter->client_next);
1004 		if (filter->next > filter->buffer &&
1005 		    filter->next + min > filter->buffer + filter->buffer_size) {
1006 			if (filter->avail > 0)
1007 				memmove(filter->buffer, filter->next, filter->avail);
1008 			filter->next = filter->buffer;
1012 		if (filter->client_avail <= 0) {
1013 			if (filter->end_of_file) {
1018 			bytes_read = (filter->read)(filter,
1019 			    &filter->client_buff);
1021 				filter->client_total = filter->client_avail = 0;
1022 				filter->client_next = filter->client_buff = NULL;
1023 				filter->fatal = 1;
1029 				filter->client_total = filter->client_avail = 0;
1030 				filter->client_next = filter->client_buff = NULL;
1031 				filter->end_of_file = 1;
1034 					*avail = filter->avail;
1037 			filter->position += bytes_read;
1038 			filter->client_total = bytes_read;
1039 			filter->client_avail = filter->client_total;
1040 			filter->client_next = filter->client_buff;
1052 			if (min > filter->buffer_size) {
1057 				s = t = filter->buffer_size;
1064 							&filter->archive->archive,
1067 						filter->fatal = 1;
1078 						&filter->archive->archive,
1081 					filter->fatal = 1;
1087 				if (filter->avail > 0)
1088 					memmove(p, filter->next, filter->avail);
1089 				free(filter->buffer);
1090 				filter->next = filter->buffer = p;
1091 				filter->buffer_size = s;
1096 			tocopy = (filter->buffer + filter->buffer_size)
1097 			    - (filter->next + filter->avail);
1099 			if (tocopy + filter->avail > min)
1100 				tocopy = min - filter->avail;
1102 			if (tocopy > filter->client_avail)
1103 				tocopy = filter->client_avail;
1105 			memcpy(filter->next + filter->avail, filter->client_next,
1108 			filter->client_next += tocopy;
1109 			filter->client_avail -= tocopy;
1111 			filter->avail += tocopy;
1131 	r = __archive_read_filter_consume(a->filter, request);
1137 __archive_read_filter_consume(struct archive_read_filter * filter,
1140 	if (filter->avail > 0) {
1142 		filter->next += request;
1143 		filter->avail -= request;
1146 		filter->client_next += request;
1147 		filter->client_avail -= request;
1178 	int64_t skipped = __archive_read_filter_skip(a->filter, request);
1185 __archive_read_filter_skip(struct archive_read_filter *filter, int64_t request)
1190 	if (filter->fatal)
1195 	if (filter->avail > 0) {
1196 		min = minimum(request, (off_t)filter->avail);
1197 		bytes_skipped = __archive_read_filter_consume(filter, min);
1201 	if (filter->client_avail > 0) {
1202 		min = minimum(request, (int64_t)filter->client_avail);
1203 		bytes_skipped = __archive_read_filter_consume(filter, min);
1213 	if ((filter->skip != NULL) && (request < SSIZE_MAX)) {
1215 	if (filter->skip != NULL) {
1217 		bytes_skipped = (filter->skip)(filter, request);
1219 			filter->client_total = filter->client_avail = 0;
1220 			filter->client_next = filter->client_buff = NULL;
1221 			filter->fatal = 1;
1226 		filter->client_next = filter->client_buff;
1227 		filter->client_avail = filter->client_total = 0;
1237 		(void)__archive_read_filter_ahead(filter, 1, &bytes_read);
1244 		bytes_read = __archive_read_filter_consume(filter, min);