PHP4用户手册:函数->CURL->curl_close

最新推荐文章于 2021-04-09 10:55:35 发布
原创 最新推荐文章于 2021-04-09 10:55:35 发布 · 640 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#php

由于博客内容为空，暂无法提供包含关键信息的摘要。

curl_close

(PHP 4 >= 4.0.2)

curl_close -- 关闭一个CURL会话

描述

　

void curl_close (int ch)

　

这个函数关闭一个CURL会话，并且释放所有的资源。CURL句柄(ch参数)也被删除。


php使用curl出现Expect:100-continue解决方法
10-24
具体的做法是在发送请求之前，使用curl的设置函数curl_setopt()，将CURLOPT_HTTPHEADER选项设置为一个包含空的“Expect”字段的数组。这样，curl就不会发送“Expect: 100-continue”了，而是直接发送POST数据。 ...
PHP4用户手册:函数->CURL->curl_close (转)
ciya3282的博客
10-31 132
PHP4用户手册:函数->CURL->curl_close (转)[@more@] curl_close (PHP 4 >= 4.0.2)curl_close--关闭一个CURL会话 描述 　 ...
PHP4用户手册:函数->CRUL->curl_init
02-05 1148
curl_init(PHP 4 >= 4.0.2)curl_init -- 初始化一个CURL会话 描述　int curl_init ([string url])　curl_init()函数将初始化一个新的会话，返回一个CURL句柄供curl_setopt(), curl_exec(),和 curl_close() 函数使用。如果可选参数被提供，那么CURLOP
PHP4用户手册:函数->CURL
键步随风
03-13 1992
PHP4用户手册:函数->CURL [本页面推荐在1024x768分辩率下浏览]文章类别：其他开发语言    转载自：ww
PHP4用户手册:函数->CRUL->curl_init (转)
csd3176的博客
12-10 107
PHP4用户手册:函数->CRUL->curl_init (转)[@more@]curl_init (PHP 4 >= 4.0.2)curl_init--初始化一个CURL会话 描述 　 int ...
php curl函数_PHP curl函数_解决curl返回空白问题
weixin_39919948的博客
03-09 1516
最后更新：2019-12-17 16:32:45 星期二修复事项：网页显示空白问题，https ssl证书校验所致在使用php开发过程中经常会需要使用curl进行获取远程页面或接口输出结果，也常用于数据抓取及采集。考虑到复用性，封装函数如下：```php/*** CURL请求函数:支持POST及基本header头信息定义* @Author 未来往事 2016-09-12* @param [api_...
php curl_exec返回错误,php - curl_exec（）总是返回false
weixin_39912580的博客
03-22 1299
错误检查和处理是程序员的朋友。 检查初始化和执行cURL函数的返回值。 如果失败，FALSE和FALSE将包含更多信息：try {$ch = curl_init();// Check if initialization had gone wrong*if ($ch === false) {throw new Exception('failed to initialize');}curl_setop...
php curl errno 3,PHP curl_errno函数
weixin_39683021的博客
04-09 1176
(PHP 4 >= 4.0.3, PHP 5)curl_errno — 返回最后一次的错误号说明intcurl_errno(resource$ch)返回最后一次cURL操作的错误号。参数ch由 curl_init() 返回的 cURL 句柄。返回值返回错误号或 0 (零) 如果没有错误发生。实例...
#include "stream_decoder.h" // 内部日志函数 static void decoder_log(StreamDecoder *decoder, LogLevel level, const char *format, ...) { if (!decoder || level > decoder->log_level) return; const char *level_str = "DEBUG"; switch(level) { case LOG_LEVEL_ERROR: level_str = "ERROR"; break; case LOG_LEVEL_WARNING: level_str = "WARN"; break; case LOG_LEVEL_INFO: level_str = "INFO"; break; default: break; } va_list args; fprintf(stderr, "[DECODER %s] ", level_str); va_start(args, format); vfprintf(stderr, format, args); va_end(args); fprintf(stderr, "\n"); } // 初始化队列 static void queue_init(struct data_queue *q) { q->head = q->tail = NULL; pthread_mutex_init(&q->mutex, NULL); pthread_cond_init(&q->cond, NULL); q->total_size = 0; q->finished = 0; q->stop_requested = 0; } // 向队列添加数据 static void queue_push(struct data_queue *q, unsigned char *data, size_t size) { if (!q || !data || size == 0) return; struct data_chunk *chunk = malloc(sizeof(struct data_chunk)); if (!chunk) return; chunk->data = malloc(size); if (!chunk->data) { free(chunk); return; } memcpy(chunk->data, data, size); chunk->size = size; chunk->next = NULL; pthread_mutex_lock(&q->mutex); if (q->tail) { q->tail->next = chunk; } else { q->head = chunk; } q->tail = chunk; q->total_size += size; pthread_cond_signal(&q->cond); pthread_mutex_unlock(&q->mutex); } // 标记队列完成 static void queue_finish(struct data_queue *q) { if (!q) return; pthread_mutex_lock(&q->mutex); q->finished = 1; pthread_cond_signal(&q->cond); pthread_mutex_unlock(&q->mutex); } // 从队列获取数据 static struct data_chunk *queue_pop(struct data_queue *q) { pthread_mutex_lock(&q->mutex); while (!q->head && !q->finished && !q->stop_requested) { pthread_cond_wait(&q->cond, &q->mutex); } if (q->stop_requested) { pthread_mutex_unlock(&q->mutex); return NULL; } if (!q->head) { pthread_mutex_unlock(&q->mutex); return NULL; } struct data_chunk *chunk = q->head; q->head = chunk->next; if (!q->head) q->tail = NULL; q->total_size -= chunk->size; pthread_mutex_unlock(&q->mutex); return chunk; } // 清理队列 static void queue_cleanup(struct data_queue *q) { if (!q) return; pthread_mutex_lock(&q->mutex); struct data_chunk *chunk = q->head; while (chunk) { struct data_chunk *next = chunk->next; free(chunk->data); free(chunk); chunk = next; } q->head = q->tail = NULL; q->total_size = 0; q->finished = 0; q->stop_requested = 0; pthread_mutex_unlock(&q->mutex); } // 头部回调函数 - 用于捕获HTTP响应头信息 static size_t header_callback(char *buffer, size_t size, size_t nitems, void *userdata) { size_t realsize = size * nitems; StreamDecoder *decoder = (StreamDecoder *)userdata; // 解析头部行 char *colon = strchr(buffer, ':'); if (colon) { *colon = '\0'; // 临时分割键值 char *key = buffer; char *value = colon + 1; // 去除前导空格 while (*value == ' ') value++; // 去除尾部换行 char *end = value + strlen(value); while (end > value && (end[-1] == '\r' || end[-1] == '\n')) { *(--end) = '\0'; } pthread_mutex_lock(&decoder->media_mutex); // 检测关键头部 if (strcasecmp(key, "Content-Type") == 0) { if (decoder->download_status.content_type) { free(decoder->download_status.content_type); } decoder->download_status.content_type = strdup(value); } else if (strcasecmp(key, "Accept-Ranges") == 0) { decoder->download_status.supports_range = (strcasecmp(value, "bytes") == 0); } else if (strcasecmp(key, "Transfer-Encoding") == 0) { decoder->download_status.is_chunked = (strstr(value, "chunked") != NULL); } else if (strcasecmp(key, "Content-Length") == 0) { decoder->download_status.content_length = atol(value); } else if (strcasecmp(key, "Content-Range") == 0) { decoder->download_status.has_content_range = 1; } else if (strcasecmp(key, "Icy-MetaInt") == 0) { decoder->download_status.is_icy_stream = 1; } pthread_mutex_unlock(&decoder->media_mutex); *colon = ':'; // 恢复原始格式 } return realsize; } // CURL写入回调 static size_t write_callback(void *contents, size_t size, size_t nmemb, void *userp) { size_t realsize = size * nmemb; struct data_queue *q = (struct data_queue *)userp; // 检查停止请求 pthread_mutex_lock(&q->mutex); if (q->stop_requested) { pthread_mutex_unlock(&q->mutex); return 0; // 返回0会中断CURL传输 } pthread_mutex_unlock(&q->mutex); queue_push(q, (unsigned char *)contents, realsize); StreamDecoder *decoder = (StreamDecoder *)q->decoder_ref; if (!decoder) return realsize; pthread_mutex_lock(&decoder->media_mutex); // 首次检测到数据时进行媒体类型判断 if (!decoder->download_status.type_detected) { // 默认初始化为未知类型 decoder->download_status.detected_type = MEDIA_TYPE_UNKNOWN; // 1. 根据Content-Type判断是否是MP3音频 if (decoder->download_status.content_type) { if (strstr(decoder->download_status.content_type, "audio/mpeg") || strstr(decoder->download_status.content_type, "audio/mp3")) { // 2. 对于MP3音频，进一步区分是完整文件还是实时流 if (decoder->download_status.supports_range || decoder->download_status.content_length > 0) { // 支持范围请求或有明确长度 = 完整文件 decoder->download_status.detected_type = MEDIA_TYPE_FILE; } else if (decoder->download_status.is_chunked || decoder->download_status.is_icy_stream || (decoder->download_status.content_length == -1)) { //分块传输或ICY流或未知长度 = 实时流 decoder->download_status.detected_type = MEDIA_TYPE_STREAM; } } else { // 非MP3内容视为流媒体 decoder->download_status.detected_type = MEDIA_TYPE_STREAM; } } // 记录检测结果 if (decoder->download_status.detected_type != MEDIA_TYPE_UNKNOWN) { const char *type_name = "未知"; switch (decoder->download_status.detected_type) { case MEDIA_TYPE_FILE: type_name = "完整MP3文件"; break; case MEDIA_TYPE_STREAM: type_name = "实时音频流"; break; default: break; } decoder_log(decoder, LOG_LEVEL_INFO, "媒体类型检测结果: %s", type_name); decoder_log(decoder, LOG_LEVEL_DEBUG, "详细信息: Content-Type=%s, Range=%s, Chunked=%s, Length=%ld", decoder->download_status.content_type ? decoder->download_status.content_type : "NULL", decoder->download_status.supports_range ? "支持" : "不支持", decoder->download_status.is_chunked ? "是" : "否", decoder->download_status.content_length); // 标记类型已检测 decoder->download_status.type_detected = 1; } } pthread_mutex_unlock(&decoder->media_mutex); return realsize; } // 应用抖动处理 static void apply_dither(short *output, float *input, size_t samples) { const float scale = 32767.0f; for (size_t i = 0; i < samples; i++) { float sample = input[i]; float dither_val = (rand() / (float)RAND_MAX) * 0.0001f; sample += dither_val; if (sample > 1.0f) sample = 1.0f; if (sample < -1.0f) sample = -1.0f; output[i] = (short)(sample * scale); } } // 解码线程 static void* decode_thread(void *arg) { StreamDecoder *decoder = (StreamDecoder *)arg; if (!decoder) return NULL; struct data_queue *q = &decoder->queue; float *buffer = NULL; size_t buffer_size = 8192 * sizeof(float); size_t done; int status; // 分配音频缓冲区 if (posix_memalign((void**)&buffer, 16, buffer_size)) { decoder_log(decoder, LOG_LEVEL_ERROR, "音频缓冲区分配失败"); return NULL; } // 分配PCM输出缓冲区 size_t max_pcm_size = 8192 * sizeof(short) * 2; // 立体声 short *pcm_buffer = malloc(max_pcm_size); if (!pcm_buffer) { decoder_log(decoder, LOG_LEVEL_ERROR, "PCM缓冲区分配失败"); free(buffer); return NULL; } srand(time(NULL)); // 等待媒体类型检测完成 time_t start_time = time(NULL); while (!decoder->download_status.type_detected && !decoder->stop_requested) { if (time(NULL) - start_time >= 5) break; usleep(100000); // 100ms } // 根据媒体类型设置初始缓冲大小 size_t initial_buffer = 0; pthread_mutex_lock(&decoder->media_mutex); switch (decoder->download_status.detected_type) { case MEDIA_TYPE_FILE: initial_buffer = 1024 * 256; // 256KB缓冲 (完整文件) break; case MEDIA_TYPE_STREAM: initial_buffer = 1024 * 1024 * 2; // 2MB缓冲 (流媒体) break; default: initial_buffer = 1024 * 512; // 默认512KB } const char *type_name = "未知"; switch (decoder->download_status.detected_type) { case MEDIA_TYPE_FILE: type_name = "文件"; break; case MEDIA_TYPE_STREAM: type_name = "流媒体"; break; default: break; } pthread_mutex_unlock(&decoder->media_mutex); decoder_log(decoder, LOG_LEVEL_INFO, "等待初始缓冲: %zu KB (%s)", initial_buffer / 1024, type_name); time_t start_wait = time(NULL); while (q->total_size < initial_buffer && !decoder->stop_requested){ if (time(NULL) - start_wait >= 2) break; usleep(100000); // 100ms休眠 } if (q->total_size >= initial_buffer) { decoder_log(decoder, LOG_LEVEL_INFO, "缓冲完成，开始解码"); } else if (decoder->stop_requested) { decoder_log(decoder, LOG_LEVEL_WARNING, "解码被中断"); free(buffer); free(pcm_buffer); return NULL; } else { decoder_log(decoder, LOG_LEVEL_WARNING, "缓冲不足，继续解码"); } while (1) { // 检查停止标志 pthread_mutex_lock(&decoder->mutex); if (decoder->stop_requested) { pthread_mutex_unlock(&decoder->mutex); break; } pthread_mutex_unlock(&decoder->mutex); struct data_chunk *chunk = queue_pop(q); if (chunk == NULL) { // 没有更多数据 break; } if (mpg123_feed(decoder->mh, chunk->data, chunk->size) != MPG123_OK) { decoder_log(decoder, LOG_LEVEL_WARNING, "数据供给失败"); free(chunk->data); free(chunk); // 尝试重置解码器 mpg123_close(decoder->mh); if (mpg123_open_feed(decoder->mh) != MPG123_OK) { decoder_log(decoder, LOG_LEVEL_ERROR, "无法重置解码器"); break; } continue; } free(chunk->data); free(chunk); while (1) { // 检查停止标志 pthread_mutex_lock(&decoder->mutex); if (decoder->stop_requested) { pthread_mutex_unlock(&decoder->mutex); break; } pthread_mutex_unlock(&decoder->mutex); status = mpg123_read(decoder->mh, (unsigned char*)buffer, buffer_size, &done); // 处理格式变化 if (status == MPG123_NEW_FORMAT) { long rate; int channels, encoding; if (mpg123_getformat(decoder->mh, &rate, &channels, &encoding) == MPG123_OK) { decoder->channels = channels; decoder->rate = rate; decoder_log(decoder, LOG_LEVEL_INFO, "音频格式: %d 声道, %ld Hz", channels, rate); } continue; } // 需要更多数据或错误 if (status == MPG123_NEED_MORE || status != MPG123_OK) { break; } // 处理解码后的PCM数据 if (done > 0) { size_t frames = done / (sizeof(float) * decoder->channels); size_t pcm_size = frames * sizeof(short) * decoder->channels; apply_dither(pcm_buffer, buffer, frames * decoder->channels); if (decoder->pcm_callback) { decoder->pcm_callback(pcm_buffer, pcm_size, decoder->channels, decoder->rate, decoder->callback_userdata); } } } } free(buffer); free(pcm_buffer); decoder_log(decoder, LOG_LEVEL_INFO, "解码线程退出"); return NULL; } // 下载线程 static void* download_thread(void *arg) { StreamDecoder *decoder = (StreamDecoder *)arg; if (!decoder || !decoder->curl) return NULL; decoder_log(decoder, LOG_LEVEL_INFO, "开始下载音频流"); // 初始化下载状态 decoder->download_status.detected_type = MEDIA_TYPE_UNKNOWN; decoder->download_status.content_type = NULL; decoder->download_status.type_detected = 0; decoder->download_status.supports_range = 0; decoder->download_status.is_chunked = 0; decoder->download_status.has_content_range = 0; decoder->download_status.is_icy_stream = 0; decoder->download_status.content_length = -1; CURLcode res = curl_easy_perform(decoder->curl); if (res == CURLE_OPERATION_TIMEDOUT) { decoder_log(decoder, LOG_LEVEL_WARNING, "下载超时"); } else if (res == CURLE_SEND_ERROR || res == CURLE_RECV_ERROR) { decoder_log(decoder, LOG_LEVEL_WARNING, "网络连接中断"); } else if (res != CURLE_OK && res != CURLE_ABORTED_BY_CALLBACK) { decoder_log(decoder, LOG_LEVEL_ERROR, "下载失败: %s", curl_easy_strerror(res)); } else { decoder_log(decoder, LOG_LEVEL_INFO, "下载完成"); } queue_finish(&decoder->queue); decoder_log(decoder, LOG_LEVEL_INFO, "下载线程退出"); return NULL; } // ================== 公共接口实现 ================== StreamDecoder* stream_decoder_create() { StreamDecoder* decoder = calloc(1, sizeof(StreamDecoder)); if (!decoder) return NULL; // 初始化队列 queue_init(&decoder->queue); decoder->queue.decoder_ref = decoder; // 设置反向引用 // 初始化下载状态 decoder->download_status.content_type = NULL; decoder->download_status.detected_type = MEDIA_TYPE_UNKNOWN; decoder->download_status.type_detected = 0; decoder->download_status.supports_range = 0; decoder->download_status.is_chunked = 0; decoder->download_status.has_content_range = 0; decoder->download_status.is_icy_stream = 0; decoder->download_status.content_length = -1; // -1表示未知 // 初始化mpg123 if (mpg123_init() != MPG123_OK) { free(decoder); return NULL; } decoder->mh = mpg123_new(NULL, NULL); if (!decoder->mh) { mpg123_exit(); free(decoder); return NULL; } if (mpg123_format_none(decoder->mh) != MPG123_OK || mpg123_format(decoder->mh, 44100, MPG123_STEREO, MPG123_ENC_FLOAT_32) != MPG123_OK) { mpg123_delete(decoder->mh); mpg123_exit(); free(decoder); return NULL; } if (mpg123_open_feed(decoder->mh) != MPG123_OK) { mpg123_delete(decoder->mh); mpg123_exit(); free(decoder); return NULL; } // 初始化互斥锁 pthread_mutex_init(&decoder->mutex, NULL); pthread_mutex_init(&decoder->media_mutex, NULL); // 初始化解码器状态 decoder->stop_requested = 0; decoder->channels = 0; decoder->rate = 0; decoder->pcm_callback = NULL; decoder->callback_userdata = NULL; decoder->log_level = LOG_LEVEL_ERROR; decoder->curl = NULL; decoder->headers = NULL; return decoder; } void stream_decoder_destroy(StreamDecoder* decoder) { if (!decoder) return; // 停止解码 stream_decoder_stop(decoder); // 清理HTTP头部 if (decoder->headers) { curl_slist_free_all(decoder->headers); decoder->headers = NULL; } // 清理下载状态 if (decoder->download_status.content_type) { free(decoder->download_status.content_type); decoder->download_status.content_type = NULL; } // 清理队列 queue_cleanup(&decoder->queue); pthread_mutex_destroy(&decoder->queue.mutex); pthread_cond_destroy(&decoder->queue.cond); // 清理mpg123 if (decoder->mh) { mpg123_close(decoder->mh); mpg123_delete(decoder->mh); } mpg123_exit(); // 销毁互斥锁 pthread_mutex_destroy(&decoder->mutex); pthread_mutex_destroy(&decoder->media_mutex); free(decoder); } void stream_decoder_set_callback(StreamDecoder* decoder, PCMCallback callback, void* userdata) { if (!decoder) return; decoder->pcm_callback = callback; decoder->callback_userdata = userdata; } void stream_decoder_set_log_level(StreamDecoder* decoder, LogLevel level) { if (!decoder) return; decoder->log_level = level; } int stream_decoder_start(StreamDecoder* decoder, const char* url) { if (!decoder || !url) return 0; decoder_log(decoder, LOG_LEVEL_INFO, "开始解码: %s", url); // 重置状态 pthread_mutex_lock(&decoder->mutex); decoder->stop_requested = 0; decoder->channels = 0; decoder->rate = 0; pthread_mutex_unlock(&decoder->mutex); // 清理队列 queue_cleanup(&decoder->queue); decoder->queue.decoder_ref = decoder; // 重置反向引用 // 重置下载状态 pthread_mutex_lock(&decoder->media_mutex); if (decoder->download_status.content_type) { free(decoder->download_status.content_type); decoder->download_status.content_type = NULL; } decoder->download_status.detected_type = MEDIA_TYPE_UNKNOWN; decoder->download_status.type_detected = 0; decoder->download_status.supports_range = 0; decoder->download_status.is_chunked = 0; decoder->download_status.has_content_range = 0; decoder->download_status.is_icy_stream = 0; decoder->download_status.content_length = -1; pthread_mutex_unlock(&decoder->media_mutex); // 初始化curl curl_global_init(CURL_GLOBAL_DEFAULT); decoder->curl = curl_easy_init(); if (!decoder->curl) { decoder_log(decoder, LOG_LEVEL_ERROR, "无法初始化CURL"); return 0; } // 设置CURL选项 curl_easy_setopt(decoder->curl, CURLOPT_URL, url); curl_easy_setopt(decoder->curl, CURLOPT_WRITEFUNCTION, write_callback); curl_easy_setopt(decoder->curl, CURLOPT_WRITEDATA, &decoder->queue); // 添加头部回调 curl_easy_setopt(decoder->curl, CURLOPT_HEADERFUNCTION, header_callback); curl_easy_setopt(decoder->curl, CURLOPT_HEADERDATA, decoder); // 设置HTTP头部 if (decoder->headers) { curl_slist_free_all(decoder->headers); decoder->headers = NULL; } decoder->headers = curl_slist_append(decoder->headers, "User-Agent: StreamDecoder/1.0"); decoder->headers = curl_slist_append(decoder->headers, "Connection: keep-alive"); // 仅对可能支持范围请求的URL添加Range头 if (strstr(url, ".mp3") || strstr(url, ".mp4")) { decoder->headers = curl_slist_append(decoder->headers, "Range: bytes=0-"); } curl_easy_setopt(decoder->curl, CURLOPT_HTTPHEADER, decoder->headers); // 设置SSL选项（忽略证书验证） curl_easy_setopt(decoder->curl, CURLOPT_SSL_VERIFYPEER, 0L); curl_easy_setopt(decoder->curl, CURLOPT_SSL_VERIFYHOST, 0L); // 设置网络选项 curl_easy_setopt(decoder->curl, CURLOPT_FOLLOWLOCATION, 1L); curl_easy_setopt(decoder->curl, CURLOPT_NOSIGNAL, 1L); curl_easy_setopt(decoder->curl, CURLOPT_CONNECTTIMEOUT, 10L); curl_easy_setopt(decoder->curl, CURLOPT_TIMEOUT, 0L); // 无限超时 curl_easy_setopt(decoder->curl, CURLOPT_BUFFERSIZE, 65536L); curl_easy_setopt(decoder->curl, CURLOPT_TCP_KEEPALIVE, 1L); curl_easy_setopt(decoder->curl, CURLOPT_TCP_KEEPIDLE, 30L); curl_easy_setopt(decoder->curl, CURLOPT_TCP_KEEPINTVL, 15L); // 防止连接成功但传输极慢 curl_easy_setopt(decoder->curl, CURLOPT_LOW_SPEED_LIMIT, 1024); // 1KB/s curl_easy_setopt(decoder->curl, CURLOPT_LOW_SPEED_TIME, 10L); // 持续10秒 // 创建下载线程 if (pthread_create(&decoder->download_tid, NULL, download_thread, decoder) != 0) { decoder_log(decoder, LOG_LEVEL_ERROR, "无法创建下载线程"); curl_easy_cleanup(decoder->curl); curl_global_cleanup(); return 0; } // 创建解码线程 if (pthread_create(&decoder->decode_tid, NULL, decode_thread, decoder) != 0) { decoder_log(decoder, LOG_LEVEL_ERROR, "无法创建解码线程"); pthread_mutex_lock(&decoder->mutex); decoder->stop_requested = 1; pthread_mutex_unlock(&decoder->mutex); pthread_join(decoder->download_tid, NULL); curl_easy_cleanup(decoder->curl); curl_global_cleanup(); return 0; } return 1; } void stream_decoder_stop(StreamDecoder* decoder) { if (!decoder) return; decoder_log(decoder, LOG_LEVEL_INFO, "停止解码"); // 设置停止标志 pthread_mutex_lock(&decoder->mutex); if (decoder->stop_requested) { pthread_mutex_unlock(&decoder->mutex); return; } decoder->stop_requested = 1; pthread_mutex_unlock(&decoder->mutex); // 设置队列的停止标志 pthread_mutex_lock(&decoder->queue.mutex); decoder->queue.stop_requested = 1; pthread_cond_broadcast(&decoder->queue.cond); pthread_mutex_unlock(&decoder->queue.mutex); // 中断CURL下载 if (decoder->curl) { curl_easy_setopt(decoder->curl, CURLOPT_TIMEOUT, 1L); // 设置超时以中断下载 } // 唤醒可能等待的线程 pthread_cond_broadcast(&decoder->queue.cond); // 等待线程结束 if (pthread_self() != decoder->download_tid) { pthread_join(decoder->download_tid, NULL); } if (pthread_self() != decoder->decode_tid) { pthread_join(decoder->decode_tid, NULL); } // 清理curl if (decoder->curl) { curl_easy_cleanup(decoder->curl); decoder->curl = NULL; } curl_global_cleanup(); // 重置队列 queue_cleanup(&decoder->queue); } 输出的PCM的采样率是多少
07-10
<think>根据提供的代码，我们来分析输出的PCM采样率是多少。 在代码中，音频解码使用的是mpg123库。在初始化mpg123解码器时，我们设置了默认的格式： ```c mpg123_format(decoder->mh, 44100, MPG123_STEREO, MPG...
#include "stream_decoder.h" #include <stdio.h> #include <stdlib.h> #include <string.h> #include <pthread.h> #include <curl/curl.h> #include <mpg123.h> #include <stdarg.h> #include <time.h> #include <stdint.h> #include <unistd.h> #include <signal.h> // 数据块结构 struct data_chunk { unsigned char *data; size_t size; struct data_chunk *next; }; // 数据队列 struct data_queue { struct data_chunk *head; struct data_chunk *tail; pthread_mutex_t mutex; pthread_cond_t cond; size_t total_size; int finished; }; // 解码器状态 struct StreamDecoder { mpg123_handle *mh; pthread_mutex_t mutex; int stop_requested; // 停止请求标志 int channels; long rate; PCMCallback pcm_callback; void* callback_userdata; LogLevel log_level; pthread_t download_tid; pthread_t decode_tid; struct data_queue queue; CURL *curl; }; // 内部日志函数 static void decoder_log(StreamDecoder *decoder, LogLevel level, const char *format, ...) { if (!decoder || level > decoder->log_level) return; const char *level_str = "DEBUG"; switch(level) { case LOG_LEVEL_ERROR: level_str = "ERROR"; break; case LOG_LEVEL_WARNING: level_str = "WARN"; break; case LOG_LEVEL_INFO: level_str = "INFO"; break; default: break; } va_list args; fprintf(stderr, "[DECODER %s] ", level_str); va_start(args, format); vfprintf(stderr, format, args); va_end(args); fprintf(stderr, "\n"); } // 初始化队列 static void queue_init(struct data_queue *q) { q->head = q->tail = NULL; pthread_mutex_init(&q->mutex, NULL); pthread_cond_init(&q->cond, NULL); q->total_size = 0; q->finished = 0; } // 向队列添加数据 static void queue_push(struct data_queue *q, unsigned char *data, size_t size) { if (!q || !data || size == 0) return; struct data_chunk *chunk = malloc(sizeof(struct data_chunk)); if (!chunk) return; chunk->data = malloc(size); if (!chunk->data) { free(chunk); return; } memcpy(chunk->data, data, size); chunk->size = size; chunk->next = NULL; pthread_mutex_lock(&q->mutex); if (q->tail) { q->tail->next = chunk; } else { q->head = chunk; } q->tail = chunk; q->total_size += size; pthread_cond_signal(&q->cond); pthread_mutex_unlock(&q->mutex); } // 标记队列完成 static void queue_finish(struct data_queue *q) { if (!q) return; pthread_mutex_lock(&q->mutex); q->finished = 1; pthread_cond_signal(&q->cond); pthread_mutex_unlock(&q->mutex); } // 从队列获取数据 static struct data_chunk *queue_pop(struct data_queue *q) { if (!q) return NULL; pthread_mutex_lock(&q->mutex); while (!q->head && !q->finished && !q->stop_requested) { pthread_cond_wait(&q->cond, &q->mutex); } if (!q->head) { pthread_mutex_unlock(&q->mutex); return NULL; } struct data_chunk *chunk = q->head; q->head = chunk->next; if (!q->head) q->tail = NULL; q->total_size -= chunk->size; pthread_mutex_unlock(&q->mutex); return chunk; } // 清理队列 static void queue_cleanup(struct data_queue *q) { if (!q) return; pthread_mutex_lock(&q->mutex); struct data_chunk *chunk = q->head; while (chunk) { struct data_chunk *next = chunk->next; free(chunk->data); free(chunk); chunk = next; } q->head = q->tail = NULL; q->total_size = 0; pthread_mutex_unlock(&q->mutex); } // CURL写入回调 static size_t write_callback(void *contents, size_t size, size_t nmemb, void *userp) { size_t realsize = size * nmemb; struct data_queue *q = (struct data_queue *)userp; queue_push(q, (unsigned char *)contents, realsize); return realsize; } // 应用抖动处理 static void apply_dither(short *output, float *input, size_t samples) { const float scale = 32767.0f; for (size_t i = 0; i < samples; i++) { float sample = input[i]; float dither_val = (rand() / (float)RAND_MAX) * 0.0001f; sample += dither_val; if (sample > 1.0f) sample = 1.0f; if (sample < -1.0f) sample = -1.0f; output[i] = (short)(sample * scale); } } // 解码线程 static void* decode_thread(void *arg) { StreamDecoder *decoder = (StreamDecoder *)arg; if (!decoder) return NULL; struct data_queue *q = &decoder->queue; float *buffer = NULL; size_t buffer_size = 8192 * sizeof(float); size_t done; int status; // 分配音频缓冲区 if (posix_memalign((void**)&buffer, 16, buffer_size)) { decoder_log(decoder, LOG_LEVEL_ERROR, "音频缓冲区分配失败"); return NULL; } // 分配PCM输出缓冲区 size_t max_pcm_size = 8192 * sizeof(short) * 2; // 立体声 short *pcm_buffer = malloc(max_pcm_size); if (!pcm_buffer) { decoder_log(decoder, LOG_LEVEL_ERROR, "PCM缓冲区分配失败"); free(buffer); return NULL; } srand(time(NULL)); while (1) { // 检查停止标志 pthread_mutex_lock(&decoder->mutex); if (decoder->stop_requested) { pthread_mutex_unlock(&decoder->mutex); break; } pthread_mutex_unlock(&decoder->mutex); struct data_chunk *chunk = queue_pop(q); if (chunk == NULL) { // 没有更多数据 break; } if (mpg123_feed(decoder->mh, chunk->data, chunk->size) != MPG123_OK) { decoder_log(decoder, LOG_LEVEL_WARNING, "数据供给失败"); free(chunk->data); free(chunk); continue; } free(chunk->data); free(chunk); while (1) { // 检查停止标志 pthread_mutex_lock(&decoder->mutex); if (decoder->stop_requested) { pthread_mutex_unlock(&decoder->mutex); break; } pthread_mutex_unlock(&decoder->mutex); status = mpg123_read(decoder->mh, (unsigned char*)buffer, buffer_size, &done); // 处理格式变化 if (status == MPG123_NEW_FORMAT) { long rate; int channels, encoding; if (mpg123_getformat(decoder->mh, &rate, &channels, &encoding) == MPG123_OK) { decoder->channels = channels; decoder->rate = rate; decoder_log(decoder, LOG_LEVEL_INFO, "音频格式: %d 声道, %ld Hz", channels, rate); } continue; } // 需要更多数据或错误 if (status == MPG123_NEED_MORE || status != MPG123_OK) { break; } // 处理解码后的PCM数据 if (done > 0) { size_t frames = done / (sizeof(float) * decoder->channels); size_t pcm_size = frames * sizeof(short) * decoder->channels; apply_dither(pcm_buffer, buffer, frames * decoder->channels); if (decoder->pcm_callback) { decoder->pcm_callback(pcm_buffer, pcm_size, decoder->channels, decoder->rate, decoder->callback_userdata); } } } } free(buffer); free(pcm_buffer); decoder_log(decoder, LOG_LEVEL_INFO, "解码线程退出"); return NULL; } // 下载线程 static void* download_thread(void *arg) { StreamDecoder *decoder = (StreamDecoder *)arg; if (!decoder || !decoder->curl) return NULL; decoder_log(decoder, LOG_LEVEL_INFO, "开始下载音频流"); CURLcode res = curl_easy_perform(decoder->curl); if (res != CURLE_OK) { decoder_log(decoder, LOG_LEVEL_ERROR, "下载失败: %s", curl_easy_strerror(res)); } else { decoder_log(decoder, LOG_LEVEL_INFO, "下载完成"); } queue_finish(&decoder->queue); decoder_log(decoder, LOG_LEVEL_INFO, "下载线程退出"); return NULL; } // ================== 公共接口实现 ================== StreamDecoder* stream_decoder_create() { StreamDecoder* decoder = calloc(1, sizeof(StreamDecoder)); if (!decoder) return NULL; // 初始化队列 queue_init(&decoder->queue); // 初始化mpg123 if (mpg123_init() != MPG123_OK) { free(decoder); return NULL; } decoder->mh = mpg123_new(NULL, NULL); if (!decoder->mh) { mpg123_exit(); free(decoder); return NULL; } if (mpg123_format_none(decoder->mh) != MPG123_OK || mpg123_format(decoder->mh, 44100, MPG123_STEREO, MPG123_ENC_FLOAT_32) != MPG123_OK) { mpg123_delete(decoder->mh); mpg123_exit(); free(decoder); return NULL; } if (mpg123_open_feed(decoder->mh) != MPG123_OK) { mpg123_delete(decoder->mh); mpg123_exit(); free(decoder); return NULL; } // 初始化互斥锁 pthread_mutex_init(&decoder->mutex, NULL); // 初始化解码器状态 decoder->stop_requested = 0; decoder->channels = 0; decoder->rate = 0; decoder->pcm_callback = NULL; decoder->callback_userdata = NULL; decoder->log_level = LOG_LEVEL_ERROR; decoder->curl = NULL; return decoder; } void stream_decoder_destroy(StreamDecoder* decoder) { if (!decoder) return; // 停止解码 stream_decoder_stop(decoder); // 清理队列 queue_cleanup(&decoder->queue); // 清理mpg123 if (decoder->mh) { mpg123_close(decoder->mh); mpg123_delete(decoder->mh); } mpg123_exit(); // 销毁互斥锁 pthread_mutex_destroy(&decoder->mutex); free(decoder); } void stream_decoder_set_callback(StreamDecoder* decoder, PCMCallback callback, void* userdata) { if (!decoder) return; decoder->pcm_callback = callback; decoder->callback_userdata = userdata; } void stream_decoder_set_log_level(StreamDecoder* decoder, LogLevel level) { if (!decoder) return; decoder->log_level = level; } int stream_decoder_start(StreamDecoder* decoder, const char* url) { if (!decoder || !url) return 0; decoder_log(decoder, LOG_LEVEL_INFO, "开始解码: %s", url); // 重置状态 pthread_mutex_lock(&decoder->mutex); decoder->stop_requested = 0; decoder->channels = 0; decoder->rate = 0; pthread_mutex_unlock(&decoder->mutex); // 清理队列 queue_cleanup(&decoder->queue); queue_init(&decoder->queue); // 初始化curl curl_global_init(CURL_GLOBAL_DEFAULT); decoder->curl = curl_easy_init(); if (!decoder->curl) { decoder_log(decoder, LOG_LEVEL_ERROR, "无法初始化CURL"); return 0; } // 设置CURL选项 curl_easy_setopt(decoder->curl, CURLOPT_URL, url); curl_easy_setopt(decoder->curl, CURLOPT_WRITEFUNCTION, write_callback); curl_easy_setopt(decoder->curl, CURLOPT_WRITEDATA, &decoder->queue); curl_easy_setopt(decoder->curl, CURLOPT_USERAGENT, "AudioStreamDecoder/1.0"); curl_easy_setopt(decoder->curl, CURLOPT_FOLLOWLOCATION, 1L); curl_easy_setopt(decoder->curl, CURLOPT_NOSIGNAL, 1L); curl_easy_setopt(decoder->curl, CURLOPT_CONNECTTIMEOUT, 10L); curl_easy_setopt(decoder->curl, CURLOPT_TIMEOUT, 0L); // 无限超时 // 创建下载线程 if (pthread_create(&decoder->download_tid, NULL, download_thread, decoder) != 0) { decoder_log(decoder, LOG_LEVEL_ERROR, "无法创建下载线程"); curl_easy_cleanup(decoder->curl); curl_global_cleanup(); return 0; } // 创建解码线程 if (pthread_create(&decoder->decode_tid, NULL, decode_thread, decoder) != 0) { decoder_log(decoder, LOG_LEVEL_ERROR, "无法创建解码线程"); pthread_mutex_lock(&decoder->mutex); decoder->stop_requested = 1; pthread_mutex_unlock(&decoder->mutex); pthread_join(decoder->download_tid, NULL); curl_easy_cleanup(decoder->curl); curl_global_cleanup(); return 0; } return 1; } void stream_decoder_stop(StreamDecoder* decoder) { if (!decoder) return; decoder_log(decoder, LOG_LEVEL_INFO, "停止解码"); // 设置停止标志 pthread_mutex_lock(&decoder->mutex); decoder->stop_requested = 1; pthread_mutex_unlock(&decoder->mutex); // 中断CURL下载 if (decoder->curl) { curl_easy_setopt(decoder->curl, CURLOPT_TIMEOUT, 1L); // 设置超时以中断下载 } // 唤醒可能等待的线程 pthread_cond_broadcast(&decoder->queue.cond); // 等待线程结束 pthread_join(decoder->download_tid, NULL); pthread_join(decoder->decode_tid, NULL); // 清理curl if (decoder->curl) { curl_easy_cleanup(decoder->curl); curl_global_cleanup(); decoder->curl = NULL; } // 重置队列 queue_cleanup(&decoder->queue); } gcc -c stream_decoder.c -o stream_decoder.o -I. -lcurl -lmpg123 -lpthread stream_decoder.c: In function ‘queue_pop’: stream_decoder.c:121:42: error: ‘struct data_queue’ has no member named ‘stop_requested’ 121 | while (!q->head && !q->finished && !q->stop_requested) {
07-09
<think>我们分析一下错误信息：在stream_decoder.c文件的121行，尝试访问结构体`data_queue`的成员`stop_requested`，但该结构体并没有这个成员。 查看代码中`struct data_queue`的定义： struct data_queue { ...
xiaoyong@DZ0105952:~$ curl -H "Range: bytes=0-100" http://127.0.0.1:8081/download --output first_10.txt % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 101 100 101 0 0 97773 0 --:--:-- --:--:-- --:--:-- 98k xiaoyong@DZ0105952:~$ curl -H "Range: bytes=1-100" http://127.0.0.1:8081/download --output first_10.txt % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 99 100 99 99 0 0 19 0 0:00:05 0:00:05 --:--:-- 0 curl: (18) transfer closed with 1 bytes remaining to read xiaoyong@DZ0105952:~$ curl -H "Range: bytes=2-100" http://127.0.0.1:8081/download --output first_10.txt % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 97 99 97 97 0 0 19 0 0:00:05 0:00:05 --:--:-- 0 curl: (18) transfer closed with 2 bytes remaining to read xiaoyong@DZ0105952:~$ curl -H "Range: bytes=0-100" http://127.0.0.1:8081/download --output first_10.txt % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 101 100 101 0 0 88674 0 --:--:-- --:--:-- --:--:-- 98k xiaoyong@DZ0105952:~$ curl -H "Range: bytes=10-100" http://127.0.0.1:8081/download --output first_10.txt % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 89 91 89 81 0 0 16 0 0:00:05 0:00:05 --:--:-- 0 curl: (18) transfer closed with 10 bytes remaining to read xiaoyong@DZ0105952:~$ curl -H "Range: bytes=50-100" http://127.0.0.1:8081/download --output first_10.txt % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 1 51 0 1 0 0 0 0 --:--:-- 0:00:05 --:--:-- 0 curl: (18) transfer closed with 50 bytes remaining to read xiaoyong@DZ0105952:~$ curl -H "Range: bytes=50-100" http://127.0.0.1:8081/download --output first_10.txt % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 1 51 0 1 0 0 0 0 --:--:-- 0:00:05 --:--:-- 0 curl: (18) transfer closed with 50 bytes remaining to read xiaoyong@DZ0105952:~$ curl -H "Range: bytes=50-100" http://127.0.0.1:8081/download --output first_10.txt % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 1 51 0 1 0 0 0 0 --:--:-- 0:00:05 --:--:-- 0 curl: (18) transfer closed with 50 bytes remaining to read xiaoyong@DZ0105952:~$ curl -H "Range: bytes=0-100" http://127.0.0.1:8081/download --output first_10.txt % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 101 100 101 0 0 61811 0 --:--:-- --:--:-- --:--:-- 98k xiaoyong@DZ0105952:~$ curl -H "Range: bytes=10-100" http://127.0.0.1:8081/download --output first_10.txt % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 89 91 89 81 0 0 16 0 0:00:05 0:00:05 --:--:-- 0 curl: (18) transfer closed with 10 bytes remaining to read
07-12
// 修改4：强制关闭TCP连接 res.set_header("Connection", "close"); res.set_content(std::string(buffer.data(), bytes_read), "application/octet-stream"); ... } ``` --- ### 验证步骤 1. **测试非零...
From 76f83f0db23846e254d940ec7fe141010077eb88 Mon Sep 17 00:00:00 2001 From: Daniel Stenberg <daniel@haxx.se> Date: Fri, 24 Jan 2025 11:13:24 +0100 Subject: [PATCH] content_encoding: drop support for zlib before 1.2.0.4 zlib 1.2.0.4 was released on 10 August 2003 Closes #16079 --- docs/INTERNALS.md | 2 +- lib/content_encoding.c | 276 ++++------------------------------------- 2 files changed, 25 insertions(+), 253 deletions(-) diff --git a/docs/INTERNALS.md b/docs/INTERNALS.md index ae77f0e54b05..4e42f4fd1015 100644 --- a/docs/INTERNALS.md +++ b/docs/INTERNALS.md @@ -26,7 +26,7 @@ versions of libs and build tools. - OpenSSL 0.9.7 - GnuTLS 3.1.10 - - zlib 1.1.4 + - zlib 1.2.0.4 - libssh2 1.0 - c-ares 1.16.0 - libidn2 2.0.0 diff --git a/lib/content_encoding.c b/lib/content_encoding.c index e19595d5ec42..d2b17297890d 100644 --- a/lib/content_encoding.c +++ b/lib/content_encoding.c @@ -68,33 +68,13 @@ #define DSIZ CURL_MAX_WRITE_SIZE /* buffer size for decompressed data */ - #ifdef HAVE_LIBZ -/* Comment this out if zlib is always going to be at least ver. 1.2.0.4 - (doing so will reduce code size slightly). */ -#define OLD_ZLIB_SUPPORT 1 - -#define GZIP_MAGIC_0 0x1f -#define GZIP_MAGIC_1 0x8b - -/* gzip flag byte */ -#define CURL_GZIPFLAG_ASCII 0x01 /* bit 0 set: file probably ASCII - text */ -#define CURL_GZIPFLAG_HEAD_CRC 0x02 /* bit 1 set: header CRC present */ -#define CURL_GZIPFLAG_EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ -#define CURL_GZIPFLAG_ORIG_NAME 0x08 /* bit 3 set: original filename - present */ -#define CURL_GZIPFLAG_COMMENT 0x10 /* bit 4 set: file comment present */ -#define CURL_GZIPFLAG_RESERVED 0xE0 /* bits 5..7: reserved */ - typedef enum { ZLIB_UNINIT, /* uninitialized */ ZLIB_INIT, /* initialized */ ZLIB_INFLATING, /* inflating started. */ ZLIB_EXTERNAL_TRAILER, /* reading external trailer */ - ZLIB_GZIP_HEADER, /* reading gzip header */ - ZLIB_GZIP_INFLATING, /* inflating gzip stream */ ZLIB_INIT_GZIP /* initialized in transparent gzip mode */ } zlibInitState; @@ -139,9 +119,6 @@ static CURLcode exit_zlib(struct Curl_easy *data, z_stream *z, zlibInitState *zlib_init, CURLcode result) { - if(*zlib_init == ZLIB_GZIP_HEADER) - Curl_safefree(z->next_in); - if(*zlib_init != ZLIB_UNINIT) { if(inflateEnd(z) != Z_OK && result == CURLE_OK) result = process_zlib_error(data, z); @@ -190,8 +167,7 @@ static CURLcode inflate_stream(struct Curl_easy *data, /* Check state. */ if(zp->zlib_init != ZLIB_INIT && zp->zlib_init != ZLIB_INFLATING && - zp->zlib_init != ZLIB_INIT_GZIP && - zp->zlib_init != ZLIB_GZIP_INFLATING) + zp->zlib_init != ZLIB_INIT_GZIP) return exit_zlib(data, z, &zp->zlib_init, CURLE_WRITE_ERROR); /* Dynamically allocate a buffer for decompression because it is uncommonly @@ -280,7 +256,7 @@ static CURLcode inflate_stream(struct Curl_easy *data, /* Deflate handler. */ static CURLcode deflate_do_init(struct Curl_easy *data, - struct Curl_cwriter *writer) + struct Curl_cwriter *writer) { struct zlib_writer *zp = (struct zlib_writer *) writer; z_stream *z = &zp->z; /* zlib state structure */ @@ -296,8 +272,8 @@ static CURLcode deflate_do_init(struct Curl_easy *data, } static CURLcode deflate_do_write(struct Curl_easy *data, - struct Curl_cwriter *writer, int type, - const char *buf, size_t nbytes) + struct Curl_cwriter *writer, int type, + const char *buf, size_t nbytes) { struct zlib_writer *zp = (struct zlib_writer *) writer; z_stream *z = &zp->z; /* zlib state structure */ @@ -317,7 +293,7 @@ static CURLcode deflate_do_write(struct Curl_easy *data, } static void deflate_do_close(struct Curl_easy *data, - struct Curl_cwriter *writer) + struct Curl_cwriter *writer) { struct zlib_writer *zp = (struct zlib_writer *) writer; z_stream *z = &zp->z; /* zlib state structure */ @@ -337,124 +313,34 @@ static const struct Curl_cwtype deflate_encoding = { /* Gzip handler. */ static CURLcode gzip_do_init(struct Curl_easy *data, - struct Curl_cwriter *writer) + struct Curl_cwriter *writer) { struct zlib_writer *zp = (struct zlib_writer *) writer; z_stream *z = &zp->z; /* zlib state structure */ + const char *v = zlibVersion(); /* Initialize zlib */ z->zalloc = (alloc_func) zalloc_cb; z->zfree = (free_func) zfree_cb; - if(strcmp(zlibVersion(), "1.2.0.4") >= 0) { - /* zlib ver. >= 1.2.0.4 supports transparent gzip decompressing */ + if(strcmp(v, "1.2.0.4") >= 0) { + /* zlib version >= 1.2.0.4 supports transparent gzip decompressing */ if(inflateInit2(z, MAX_WBITS + 32) != Z_OK) { return process_zlib_error(data, z); } zp->zlib_init = ZLIB_INIT_GZIP; /* Transparent gzip decompress state */ } else { - /* we must parse the gzip header and trailer ourselves */ - if(inflateInit2(z, -MAX_WBITS) != Z_OK) { - return process_zlib_error(data, z); - } - zp->trailerlen = 8; /* A CRC-32 and a 32-bit input size (RFC 1952, 2.2) */ - zp->zlib_init = ZLIB_INIT; /* Initial call state */ + failf(data, "too old zlib version: %s", v); + return CURLE_FAILED_INIT; } return CURLE_OK; } -#ifdef OLD_ZLIB_SUPPORT -/* Skip over the gzip header */ -typedef enum { - GZIP_OK, - GZIP_BAD, - GZIP_UNDERFLOW -} gzip_status; - -static gzip_status check_gzip_header(unsigned char const *data, ssize_t len, - ssize_t *headerlen) -{ - int method, flags; - const ssize_t totallen = len; - - /* The shortest header is 10 bytes */ - if(len < 10) - return GZIP_UNDERFLOW; - - if((data[0] != GZIP_MAGIC_0) || (data[1] != GZIP_MAGIC_1)) - return GZIP_BAD; - - method = data[2]; - flags = data[3]; - - if(method != Z_DEFLATED || (flags & CURL_GZIPFLAG_RESERVED) != 0) { - /* cannot handle this compression method or unknown flag */ - return GZIP_BAD; - } - - /* Skip over time, xflags, OS code and all previous bytes */ - len -= 10; - data += 10; - - if(flags & CURL_GZIPFLAG_EXTRA_FIELD) { - ssize_t extra_len; - - if(len < 2) - return GZIP_UNDERFLOW; - - extra_len = (data[1] << 8) | data[0]; - - if(len < (extra_len + 2)) - return GZIP_UNDERFLOW; - - len -= (extra_len + 2); - data += (extra_len + 2); - } - - if(flags & CURL_GZIPFLAG_ORIG_NAME) { - /* Skip over NUL-terminated filename */ - while(len && *data) { - --len; - ++data; - } - if(!len || *data) - return GZIP_UNDERFLOW; - - /* Skip over the NUL */ - --len; - ++data; - } - - if(flags & CURL_GZIPFLAG_COMMENT) { - /* Skip over NUL-terminated comment */ - while(len && *data) { - --len; - ++data; - } - if(!len || *data) - return GZIP_UNDERFLOW; - - /* Skip over the NUL */ - --len; - } - - if(flags & CURL_GZIPFLAG_HEAD_CRC) { - if(len < 2) - return GZIP_UNDERFLOW; - - len -= 2; - } - - *headerlen = totallen - len; - return GZIP_OK; -} -#endif - static CURLcode gzip_do_write(struct Curl_easy *data, - struct Curl_cwriter *writer, int type, - const char *buf, size_t nbytes) + struct Curl_cwriter *writer, int type, + const char *buf, size_t nbytes) { struct zlib_writer *zp = (struct zlib_writer *) writer; z_stream *z = &zp->z; /* zlib state structure */ @@ -470,117 +356,8 @@ static CURLcode gzip_do_write(struct Curl_easy *data, return inflate_stream(data, writer, type, ZLIB_INIT_GZIP); } -#ifndef OLD_ZLIB_SUPPORT - /* Support for old zlib versions is compiled away and we are running with - an old version, so return an error. */ + /* We are running with an old version: return error. */ return exit_zlib(data, z, &zp->zlib_init, CURLE_WRITE_ERROR); - -#else - /* This next mess is to get around the potential case where there is not - * enough data passed in to skip over the gzip header. If that happens, we - * malloc a block and copy what we have then wait for the next call. If - * there still is not enough (this is definitely a worst-case scenario), we - * make the block bigger, copy the next part in and keep waiting. - * - * This is only required with zlib versions < 1.2.0.4 as newer versions - * can handle the gzip header themselves. - */ - - switch(zp->zlib_init) { - /* Skip over gzip header? */ - case ZLIB_INIT: - { - /* Initial call state */ - ssize_t hlen; - - switch(check_gzip_header((unsigned char *) buf, nbytes, &hlen)) { - case GZIP_OK: - z->next_in = (Bytef *) buf + hlen; - z->avail_in = (uInt) (nbytes - hlen); - zp->zlib_init = ZLIB_GZIP_INFLATING; /* Inflating stream state */ - break; - - case GZIP_UNDERFLOW: - /* We need more data so we can find the end of the gzip header. it is - * possible that the memory block we malloc here will never be freed if - * the transfer abruptly aborts after this point. Since it is unlikely - * that circumstances will be right for this code path to be followed in - * the first place, and it is even more unlikely for a transfer to fail - * immediately afterwards, it should seldom be a problem. - */ - z->avail_in = (uInt) nbytes; - z->next_in = malloc(z->avail_in); - if(!z->next_in) { - return exit_zlib(data, z, &zp->zlib_init, CURLE_OUT_OF_MEMORY); - } - memcpy(z->next_in, buf, z->avail_in); - zp->zlib_init = ZLIB_GZIP_HEADER; /* Need more gzip header data state */ - /* We do not have any data to inflate yet */ - return CURLE_OK; - - case GZIP_BAD: - default: - return exit_zlib(data, z, &zp->zlib_init, process_zlib_error(data, z)); - } - - } - break; - - case ZLIB_GZIP_HEADER: - { - /* Need more gzip header data state */ - ssize_t hlen; - z->avail_in += (uInt) nbytes; - z->next_in = Curl_saferealloc(z->next_in, z->avail_in); - if(!z->next_in) { - return exit_zlib(data, z, &zp->zlib_init, CURLE_OUT_OF_MEMORY); - } - /* Append the new block of data to the previous one */ - memcpy(z->next_in + z->avail_in - nbytes, buf, nbytes); - - switch(check_gzip_header(z->next_in, (ssize_t)z->avail_in, &hlen)) { - case GZIP_OK: - /* This is the zlib stream data */ - free(z->next_in); - /* Do not point into the malloced block since we just freed it */ - z->next_in = (Bytef *) buf + hlen + nbytes - z->avail_in; - z->avail_in = z->avail_in - (uInt)hlen; - zp->zlib_init = ZLIB_GZIP_INFLATING; /* Inflating stream state */ - break; - - case GZIP_UNDERFLOW: - /* We still do not have any data to inflate! */ - return CURLE_OK; - - case GZIP_BAD: - default: - return exit_zlib(data, z, &zp->zlib_init, process_zlib_error(data, z)); - } - - } - break; - - case ZLIB_EXTERNAL_TRAILER: - z->next_in = (Bytef *) buf; - z->avail_in = (uInt) nbytes; - return process_trailer(data, zp); - - case ZLIB_GZIP_INFLATING: - default: - /* Inflating stream state */ - z->next_in = (Bytef *) buf; - z->avail_in = (uInt) nbytes; - break; - } - - if(z->avail_in == 0) { - /* We do not have any data to inflate; wait until next time */ - return CURLE_OK; - } - - /* We have parsed the header, now uncompress the data */ - return inflate_stream(data, writer, type, ZLIB_GZIP_INFLATING); -#endif } static void gzip_do_close(struct Curl_easy *data, @@ -603,7 +380,6 @@ static const struct Curl_cwtype gzip_encoding = { #endif /* HAVE_LIBZ */ - #ifdef HAVE_BROTLI /* Brotli writer. */ struct brotli_writer { @@ -650,7 +426,7 @@ static CURLcode brotli_map_error(BrotliDecoderErrorCode be) } static CURLcode brotli_do_init(struct Curl_easy *data, - struct Curl_cwriter *writer) + struct Curl_cwriter *writer) { struct brotli_writer *bp = (struct brotli_writer *) writer; (void) data; @@ -660,8 +436,8 @@ static CURLcode brotli_do_init(struct Curl_easy *data, } static CURLcode brotli_do_write(struct Curl_easy *data, - struct Curl_cwriter *writer, int type, - const char *buf, size_t nbytes) + struct Curl_cwriter *writer, int type, + const char *buf, size_t nbytes) { struct brotli_writer *bp = (struct brotli_writer *) writer; const uint8_t *src = (const uint8_t *) buf; @@ -733,7 +509,6 @@ static const struct Curl_cwtype brotli_encoding = { }; #endif - #ifdef HAVE_ZSTD /* Zstd writer. */ struct zstd_writer { @@ -757,7 +532,7 @@ static void Curl_zstd_free(void *opaque, void *address) #endif static CURLcode zstd_do_init(struct Curl_easy *data, - struct Curl_cwriter *writer) + struct Curl_cwriter *writer) { struct zstd_writer *zp = (struct zstd_writer *) writer; @@ -778,8 +553,8 @@ static CURLcode zstd_do_init(struct Curl_easy *data, } static CURLcode zstd_do_write(struct Curl_easy *data, - struct Curl_cwriter *writer, int type, - const char *buf, size_t nbytes) + struct Curl_cwriter *writer, int type, + const char *buf, size_t nbytes) { CURLcode result = CURLE_OK; struct zstd_writer *zp = (struct zstd_writer *) writer; @@ -810,7 +585,7 @@ static CURLcode zstd_do_write(struct Curl_easy *data, } if(out.pos > 0) { result = Curl_cwriter_write(data, writer->next, type, - zp->decomp, out.pos); + zp->decomp, out.pos); if(result) break; } @@ -848,7 +623,6 @@ static const struct Curl_cwtype zstd_encoding = { }; #endif - /* Identity handler. */ static const struct Curl_cwtype identity_encoding = { "identity", @@ -859,7 +633,6 @@ static const struct Curl_cwtype identity_encoding = { sizeof(struct Curl_cwriter) }; - /* supported general content decoders. */ static const struct Curl_cwtype * const general_unencoders[] = { &identity_encoding, @@ -923,7 +696,7 @@ void Curl_all_content_encodings(char *buf, size_t blen) /* Deferred error dummy writer. */ static CURLcode error_do_init(struct Curl_easy *data, - struct Curl_cwriter *writer) + struct Curl_cwriter *writer) { (void)data; (void)writer; @@ -931,8 +704,8 @@ static CURLcode error_do_init(struct Curl_easy *data, } static CURLcode error_do_write(struct Curl_easy *data, - struct Curl_cwriter *writer, int type, - const char *buf, size_t nbytes) + struct Curl_cwriter *writer, int type, + const char *buf, size_t nbytes) { (void) writer; (void) buf; @@ -1107,5 +880,4 @@ void Curl_all_content_encodings(char *buf, size_t blen) strcpy(buf, CONTENT_ENCODING_DEFAULT); } - #endif /* CURL_DISABLE_HTTP */ 上边的这个是个patch 下边的是我的源码，但是是以压缩包的形式存在的，不能修改源码 /*************************************************************************** * _ _ ____ _ * Project ___| | | | _ \| | * / __| | | | |_) | | * | (__| |_| | _ <| |___ * \___|\___/|_| \_\_____| * * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al. * * This software is licensed as described in the file COPYING, which * you should have received as part of this distribution. The terms * are also available at https://curl.se/docs/copyright.html. * * You may opt to use, copy, modify, merge, publish, distribute and/or sell * copies of the Software, and permit persons to whom the Software is * furnished to do so, under the terms of the COPYING file. * * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * * SPDX-License-Identifier: curl * ***************************************************************************/ #include "curl_setup.h" #include "urldata.h" #include <curl/curl.h> #include <stddef.h> #ifdef HAVE_LIBZ #include <zlib.h> #endif #ifdef HAVE_BROTLI #include <brotli/decode.h> #endif #ifdef HAVE_ZSTD #include <zstd.h> #endif #include "sendf.h" #include "http.h" #include "content_encoding.h" #include "strdup.h" #include "strcase.h" #include "curl_memory.h" #include "memdebug.h" #define CONTENT_ENCODING_DEFAULT "identity" #ifndef CURL_DISABLE_HTTP #define DSIZ CURL_MAX_WRITE_SIZE /* buffer size for decompressed data */ #ifdef HAVE_LIBZ /* Comment this out if zlib is always going to be at least ver. 1.2.0.4 (doing so will reduce code size slightly). */ #define OLD_ZLIB_SUPPORT 1 #define GZIP_MAGIC_0 0x1f #define GZIP_MAGIC_1 0x8b /* gzip flag byte */ #define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ #define HEAD_CRC 0x02 /* bit 1 set: header CRC present */ #define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ #define ORIG_NAME 0x08 /* bit 3 set: original file name present */ #define COMMENT 0x10 /* bit 4 set: file comment present */ #define RESERVED 0xE0 /* bits 5..7: reserved */ typedef enum { ZLIB_UNINIT, /* uninitialized */ ZLIB_INIT, /* initialized */ ZLIB_INFLATING, /* inflating started. */ ZLIB_EXTERNAL_TRAILER, /* reading external trailer */ ZLIB_GZIP_HEADER, /* reading gzip header */ ZLIB_GZIP_INFLATING, /* inflating gzip stream */ ZLIB_INIT_GZIP /* initialized in transparent gzip mode */ } zlibInitState; /* Deflate and gzip writer. */ struct zlib_writer { struct contenc_writer super; zlibInitState zlib_init; /* zlib init state */ uInt trailerlen; /* Remaining trailer byte count. */ z_stream z; /* State structure for zlib. */ }; static voidpf zalloc_cb(voidpf opaque, unsigned int items, unsigned int size) { (void) opaque; /* not a typo, keep it calloc() */ return (voidpf) calloc(items, size); } static void zfree_cb(voidpf opaque, voidpf ptr) { (void) opaque; free(ptr); } static CURLcode process_zlib_error(struct Curl_easy *data, z_stream *z) { if(z->msg) failf(data, "Error while processing content unencoding: %s", z->msg); else failf(data, "Error while processing content unencoding: " "Unknown failure within decompression software."); return CURLE_BAD_CONTENT_ENCODING; } static CURLcode exit_zlib(struct Curl_easy *data, z_stream *z, zlibInitState *zlib_init, CURLcode result) { if(*zlib_init == ZLIB_GZIP_HEADER) Curl_safefree(z->next_in); if(*zlib_init != ZLIB_UNINIT) { if(inflateEnd(z) != Z_OK && result == CURLE_OK) result = process_zlib_error(data, z); *zlib_init = ZLIB_UNINIT; } return result; } static CURLcode process_trailer(struct Curl_easy *data, struct zlib_writer *zp) { z_stream *z = &zp->z; CURLcode result = CURLE_OK; uInt len = z->avail_in < zp->trailerlen? z->avail_in: zp->trailerlen; /* Consume expected trailer bytes. Terminate stream if exhausted. Issue an error if unexpected bytes follow. */ zp->trailerlen -= len; z->avail_in -= len; z->next_in += len; if(z->avail_in) result = CURLE_WRITE_ERROR; if(result || !zp->trailerlen) result = exit_zlib(data, z, &zp->zlib_init, result); else { /* Only occurs for gzip with zlib < 1.2.0.4 or raw deflate. */ zp->zlib_init = ZLIB_EXTERNAL_TRAILER; } return result; } static CURLcode inflate_stream(struct Curl_easy *data, struct contenc_writer *writer, zlibInitState started) { struct zlib_writer *zp = (struct zlib_writer *) writer; z_stream *z = &zp->z; /* zlib state structure */ uInt nread = z->avail_in; Bytef *orig_in = z->next_in; bool done = FALSE; CURLcode result = CURLE_OK; /* Curl_client_write status */ char *decomp; /* Put the decompressed data here. */ /* Check state. */ if(zp->zlib_init != ZLIB_INIT && zp->zlib_init != ZLIB_INFLATING && zp->zlib_init != ZLIB_INIT_GZIP && zp->zlib_init != ZLIB_GZIP_INFLATING) return exit_zlib(data, z, &zp->zlib_init, CURLE_WRITE_ERROR); /* Dynamically allocate a buffer for decompression because it's uncommonly large to hold on the stack */ decomp = malloc(DSIZ); if(!decomp) return exit_zlib(data, z, &zp->zlib_init, CURLE_OUT_OF_MEMORY); /* because the buffer size is fixed, iteratively decompress and transfer to the client via downstream_write function. */ while(!done) { int status; /* zlib status */ done = TRUE; /* (re)set buffer for decompressed output for every iteration */ z->next_out = (Bytef *) decomp; z->avail_out = DSIZ; #ifdef Z_BLOCK /* Z_BLOCK is only available in zlib ver. >= 1.2.0.5 */ status = inflate(z, Z_BLOCK); #else /* fallback for zlib ver. < 1.2.0.5 */ status = inflate(z, Z_SYNC_FLUSH); #endif /* Flush output data if some. */ if(z->avail_out != DSIZ) { if(status == Z_OK || status == Z_STREAM_END) { zp->zlib_init = started; /* Data started. */ result = Curl_unencode_write(data, writer->downstream, decomp, DSIZ - z->avail_out); if(result) { exit_zlib(data, z, &zp->zlib_init, result); break; } } } /* Dispatch by inflate() status. */ switch(status) { case Z_OK: /* Always loop: there may be unflushed latched data in zlib state. */ done = FALSE; break; case Z_BUF_ERROR: /* No more data to flush: just exit loop. */ break; case Z_STREAM_END: result = process_trailer(data, zp); break; case Z_DATA_ERROR: /* some servers seem to not generate zlib headers, so this is an attempt to fix and continue anyway */ if(zp->zlib_init == ZLIB_INIT) { /* Do not use inflateReset2(): only available since zlib 1.2.3.4. */ (void) inflateEnd(z); /* don't care about the return code */ if(inflateInit2(z, -MAX_WBITS) == Z_OK) { z->next_in = orig_in; z->avail_in = nread; zp->zlib_init = ZLIB_INFLATING; zp->trailerlen = 4; /* Tolerate up to 4 unknown trailer bytes. */ done = FALSE; break; } zp->zlib_init = ZLIB_UNINIT; /* inflateEnd() already called. */ } result = exit_zlib(data, z, &zp->zlib_init, process_zlib_error(data, z)); break; default: result = exit_zlib(data, z, &zp->zlib_init, process_zlib_error(data, z)); break; } } free(decomp); /* We're about to leave this call so the `nread' data bytes won't be seen again. If we are in a state that would wrongly allow restart in raw mode at the next call, assume output has already started. */ if(nread && zp->zlib_init == ZLIB_INIT) zp->zlib_init = started; /* Cannot restart anymore. */ return result; } /* Deflate handler. */ static CURLcode deflate_init_writer(struct Curl_easy *data, struct contenc_writer *writer) { struct zlib_writer *zp = (struct zlib_writer *) writer; z_stream *z = &zp->z; /* zlib state structure */ if(!writer->downstream) return CURLE_WRITE_ERROR; /* Initialize zlib */ z->zalloc = (alloc_func) zalloc_cb; z->zfree = (free_func) zfree_cb; if(inflateInit(z) != Z_OK) return process_zlib_error(data, z); zp->zlib_init = ZLIB_INIT; return CURLE_OK; } static CURLcode deflate_unencode_write(struct Curl_easy *data, struct contenc_writer *writer, const char *buf, size_t nbytes) { struct zlib_writer *zp = (struct zlib_writer *) writer; z_stream *z = &zp->z; /* zlib state structure */ /* Set the compressed input when this function is called */ z->next_in = (Bytef *) buf; z->avail_in = (uInt) nbytes; if(zp->zlib_init == ZLIB_EXTERNAL_TRAILER) return process_trailer(data, zp); /* Now uncompress the data */ return inflate_stream(data, writer, ZLIB_INFLATING); } static void deflate_close_writer(struct Curl_easy *data, struct contenc_writer *writer) { struct zlib_writer *zp = (struct zlib_writer *) writer; z_stream *z = &zp->z; /* zlib state structure */ exit_zlib(data, z, &zp->zlib_init, CURLE_OK); } static const struct content_encoding deflate_encoding = { "deflate", NULL, deflate_init_writer, deflate_unencode_write, deflate_close_writer, sizeof(struct zlib_writer) }; /* Gzip handler. */ static CURLcode gzip_init_writer(struct Curl_easy *data, struct contenc_writer *writer) { struct zlib_writer *zp = (struct zlib_writer *) writer; z_stream *z = &zp->z; /* zlib state structure */ if(!writer->downstream) return CURLE_WRITE_ERROR; /* Initialize zlib */ z->zalloc = (alloc_func) zalloc_cb; z->zfree = (free_func) zfree_cb; if(strcmp(zlibVersion(), "1.2.0.4") >= 0) { /* zlib ver. >= 1.2.0.4 supports transparent gzip decompressing */ if(inflateInit2(z, MAX_WBITS + 32) != Z_OK) { return process_zlib_error(data, z); } zp->zlib_init = ZLIB_INIT_GZIP; /* Transparent gzip decompress state */ } else { /* we must parse the gzip header and trailer ourselves */ if(inflateInit2(z, -MAX_WBITS) != Z_OK) { return process_zlib_error(data, z); } zp->trailerlen = 8; /* A CRC-32 and a 32-bit input size (RFC 1952, 2.2) */ zp->zlib_init = ZLIB_INIT; /* Initial call state */ } return CURLE_OK; } #ifdef OLD_ZLIB_SUPPORT /* Skip over the gzip header */ static enum { GZIP_OK, GZIP_BAD, GZIP_UNDERFLOW } check_gzip_header(unsigned char const *data, ssize_t len, ssize_t *headerlen) { int method, flags; const ssize_t totallen = len; /* The shortest header is 10 bytes */ if(len < 10) return GZIP_UNDERFLOW; if((data[0] != GZIP_MAGIC_0) || (data[1] != GZIP_MAGIC_1)) return GZIP_BAD; method = data[2]; flags = data[3]; if(method != Z_DEFLATED || (flags & RESERVED) != 0) { /* Can't handle this compression method or unknown flag */ return GZIP_BAD; } /* Skip over time, xflags, OS code and all previous bytes */ len -= 10; data += 10; if(flags & EXTRA_FIELD) { ssize_t extra_len; if(len < 2) return GZIP_UNDERFLOW; extra_len = (data[1] << 8) | data[0]; if(len < (extra_len + 2)) return GZIP_UNDERFLOW; len -= (extra_len + 2); data += (extra_len + 2); } if(flags & ORIG_NAME) { /* Skip over NUL-terminated file name */ while(len && *data) { --len; ++data; } if(!len || *data) return GZIP_UNDERFLOW; /* Skip over the NUL */ --len; ++data; } if(flags & COMMENT) { /* Skip over NUL-terminated comment */ while(len && *data) { --len; ++data; } if(!len || *data) return GZIP_UNDERFLOW; /* Skip over the NUL */ --len; } if(flags & HEAD_CRC) { if(len < 2) return GZIP_UNDERFLOW; len -= 2; } *headerlen = totallen - len; return GZIP_OK; } #endif static CURLcode gzip_unencode_write(struct Curl_easy *data, struct contenc_writer *writer, const char *buf, size_t nbytes) { struct zlib_writer *zp = (struct zlib_writer *) writer; z_stream *z = &zp->z; /* zlib state structure */ if(zp->zlib_init == ZLIB_INIT_GZIP) { /* Let zlib handle the gzip decompression entirely */ z->next_in = (Bytef *) buf; z->avail_in = (uInt) nbytes; /* Now uncompress the data */ return inflate_stream(data, writer, ZLIB_INIT_GZIP); } #ifndef OLD_ZLIB_SUPPORT /* Support for old zlib versions is compiled away and we are running with an old version, so return an error. */ return exit_zlib(data, z, &zp->zlib_init, CURLE_WRITE_ERROR); #else /* This next mess is to get around the potential case where there isn't * enough data passed in to skip over the gzip header. If that happens, we * malloc a block and copy what we have then wait for the next call. If * there still isn't enough (this is definitely a worst-case scenario), we * make the block bigger, copy the next part in and keep waiting. * * This is only required with zlib versions < 1.2.0.4 as newer versions * can handle the gzip header themselves. */ switch(zp->zlib_init) { /* Skip over gzip header? */ case ZLIB_INIT: { /* Initial call state */ ssize_t hlen; switch(check_gzip_header((unsigned char *) buf, nbytes, &hlen)) { case GZIP_OK: z->next_in = (Bytef *) buf + hlen; z->avail_in = (uInt) (nbytes - hlen); zp->zlib_init = ZLIB_GZIP_INFLATING; /* Inflating stream state */ break; case GZIP_UNDERFLOW: /* We need more data so we can find the end of the gzip header. It's * possible that the memory block we malloc here will never be freed if * the transfer abruptly aborts after this point. Since it's unlikely * that circumstances will be right for this code path to be followed in * the first place, and it's even more unlikely for a transfer to fail * immediately afterwards, it should seldom be a problem. */ z->avail_in = (uInt) nbytes; z->next_in = malloc(z->avail_in); if(!z->next_in) { return exit_zlib(data, z, &zp->zlib_init, CURLE_OUT_OF_MEMORY); } memcpy(z->next_in, buf, z->avail_in); zp->zlib_init = ZLIB_GZIP_HEADER; /* Need more gzip header data state */ /* We don't have any data to inflate yet */ return CURLE_OK; case GZIP_BAD: default: return exit_zlib(data, z, &zp->zlib_init, process_zlib_error(data, z)); } } break; case ZLIB_GZIP_HEADER: { /* Need more gzip header data state */ ssize_t hlen; z->avail_in += (uInt) nbytes; z->next_in = Curl_saferealloc(z->next_in, z->avail_in); if(!z->next_in) { return exit_zlib(data, z, &zp->zlib_init, CURLE_OUT_OF_MEMORY); } /* Append the new block of data to the previous one */ memcpy(z->next_in + z->avail_in - nbytes, buf, nbytes); switch(check_gzip_header(z->next_in, z->avail_in, &hlen)) { case GZIP_OK: /* This is the zlib stream data */ free(z->next_in); /* Don't point into the malloced block since we just freed it */ z->next_in = (Bytef *) buf + hlen + nbytes - z->avail_in; z->avail_in = (uInt) (z->avail_in - hlen); zp->zlib_init = ZLIB_GZIP_INFLATING; /* Inflating stream state */ break; case GZIP_UNDERFLOW: /* We still don't have any data to inflate! */ return CURLE_OK; case GZIP_BAD: default: return exit_zlib(data, z, &zp->zlib_init, process_zlib_error(data, z)); } } break; case ZLIB_EXTERNAL_TRAILER: z->next_in = (Bytef *) buf; z->avail_in = (uInt) nbytes; return process_trailer(data, zp); case ZLIB_GZIP_INFLATING: default: /* Inflating stream state */ z->next_in = (Bytef *) buf; z->avail_in = (uInt) nbytes; break; } if(z->avail_in == 0) { /* We don't have any data to inflate; wait until next time */ return CURLE_OK; } /* We've parsed the header, now uncompress the data */ return inflate_stream(data, writer, ZLIB_GZIP_INFLATING); #endif } static void gzip_close_writer(struct Curl_easy *data, struct contenc_writer *writer) { struct zlib_writer *zp = (struct zlib_writer *) writer; z_stream *z = &zp->z; /* zlib state structure */ exit_zlib(data, z, &zp->zlib_init, CURLE_OK); } static const struct content_encoding gzip_encoding = { "gzip", "x-gzip", gzip_init_writer, gzip_unencode_write, gzip_close_writer, sizeof(struct zlib_writer) }; #endif /* HAVE_LIBZ */ #ifdef HAVE_BROTLI /* Brotli writer. */ struct brotli_writer { struct contenc_writer super; BrotliDecoderState *br; /* State structure for brotli. */ }; static CURLcode brotli_map_error(BrotliDecoderErrorCode be) { switch(be) { case BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: case BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: case BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: case BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: case BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: case BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: case BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: case BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: case BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: case BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: case BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: case BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: case BROTLI_DECODER_ERROR_FORMAT_PADDING_1: case BROTLI_DECODER_ERROR_FORMAT_PADDING_2: #ifdef BROTLI_DECODER_ERROR_COMPOUND_DICTIONARY case BROTLI_DECODER_ERROR_COMPOUND_DICTIONARY: #endif #ifdef BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET case BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: #endif case BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: return CURLE_BAD_CONTENT_ENCODING; case BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: case BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: case BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: case BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: case BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: case BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: return CURLE_OUT_OF_MEMORY; default: break; } return CURLE_WRITE_ERROR; } static CURLcode brotli_init_writer(struct Curl_easy *data, struct contenc_writer *writer) { struct brotli_writer *bp = (struct brotli_writer *) writer; (void) data; if(!writer->downstream) return CURLE_WRITE_ERROR; bp->br = BrotliDecoderCreateInstance(NULL, NULL, NULL); return bp->br? CURLE_OK: CURLE_OUT_OF_MEMORY; } static CURLcode brotli_unencode_write(struct Curl_easy *data, struct contenc_writer *writer, const char *buf, size_t nbytes) { struct brotli_writer *bp = (struct brotli_writer *) writer; const uint8_t *src = (const uint8_t *) buf; char *decomp; uint8_t *dst; size_t dstleft; CURLcode result = CURLE_OK; BrotliDecoderResult r = BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT; if(!bp->br) return CURLE_WRITE_ERROR; /* Stream already ended. */ decomp = malloc(DSIZ); if(!decomp) return CURLE_OUT_OF_MEMORY; while((nbytes || r == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) && result == CURLE_OK) { dst = (uint8_t *) decomp; dstleft = DSIZ; r = BrotliDecoderDecompressStream(bp->br, &nbytes, &src, &dstleft, &dst, NULL); result = Curl_unencode_write(data, writer->downstream, decomp, DSIZ - dstleft); if(result) break; switch(r) { case BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: case BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: break; case BROTLI_DECODER_RESULT_SUCCESS: BrotliDecoderDestroyInstance(bp->br); bp->br = NULL; if(nbytes) result = CURLE_WRITE_ERROR; break; default: result = brotli_map_error(BrotliDecoderGetErrorCode(bp->br)); break; } } free(decomp); return result; } static void brotli_close_writer(struct Curl_easy *data, struct contenc_writer *writer) { struct brotli_writer *bp = (struct brotli_writer *) writer; (void) data; if(bp->br) { BrotliDecoderDestroyInstance(bp->br); bp->br = NULL; } } static const struct content_encoding brotli_encoding = { "br", NULL, brotli_init_writer, brotli_unencode_write, brotli_close_writer, sizeof(struct brotli_writer) }; #endif #ifdef HAVE_ZSTD /* Zstd writer. */ struct zstd_writer { struct contenc_writer super; ZSTD_DStream *zds; /* State structure for zstd. */ void *decomp; }; static CURLcode zstd_init_writer(struct Curl_easy *data, struct contenc_writer *writer) { struct zstd_writer *zp = (struct zstd_writer *) writer; (void)data; if(!writer->downstream) return CURLE_WRITE_ERROR; zp->zds = ZSTD_createDStream(); zp->decomp = NULL; return zp->zds ? CURLE_OK : CURLE_OUT_OF_MEMORY; } static CURLcode zstd_unencode_write(struct Curl_easy *data, struct contenc_writer *writer, const char *buf, size_t nbytes) { CURLcode result = CURLE_OK; struct zstd_writer *zp = (struct zstd_writer *) writer; ZSTD_inBuffer in; ZSTD_outBuffer out; size_t errorCode; if(!zp->decomp) { zp->decomp = malloc(DSIZ); if(!zp->decomp) return CURLE_OUT_OF_MEMORY; } in.pos = 0; in.src = buf; in.size = nbytes; for(;;) { out.pos = 0; out.dst = zp->decomp; out.size = DSIZ; errorCode = ZSTD_decompressStream(zp->zds, &out, &in); if(ZSTD_isError(errorCode)) { return CURLE_BAD_CONTENT_ENCODING; } if(out.pos > 0) { result = Curl_unencode_write(data, writer->downstream, zp->decomp, out.pos); if(result) break; } if((in.pos == nbytes) && (out.pos < out.size)) break; } return result; } static void zstd_close_writer(struct Curl_easy *data, struct contenc_writer *writer) { struct zstd_writer *zp = (struct zstd_writer *) writer; (void)data; if(zp->decomp) { free(zp->decomp); zp->decomp = NULL; } if(zp->zds) { ZSTD_freeDStream(zp->zds); zp->zds = NULL; } } static const struct content_encoding zstd_encoding = { "zstd", NULL, zstd_init_writer, zstd_unencode_write, zstd_close_writer, sizeof(struct zstd_writer) }; #endif /* Identity handler. */ static CURLcode identity_init_writer(struct Curl_easy *data, struct contenc_writer *writer) { (void) data; return writer->downstream? CURLE_OK: CURLE_WRITE_ERROR; } static CURLcode identity_unencode_write(struct Curl_easy *data, struct contenc_writer *writer, const char *buf, size_t nbytes) { return Curl_unencode_write(data, writer->downstream, buf, nbytes); } static void identity_close_writer(struct Curl_easy *data, struct contenc_writer *writer) { (void) data; (void) writer; } static const struct content_encoding identity_encoding = { "identity", "none", identity_init_writer, identity_unencode_write, identity_close_writer, sizeof(struct contenc_writer) }; /* supported content encodings table. */ static const struct content_encoding * const encodings[] = { &identity_encoding, #ifdef HAVE_LIBZ &deflate_encoding, &gzip_encoding, #endif #ifdef HAVE_BROTLI &brotli_encoding, #endif #ifdef HAVE_ZSTD &zstd_encoding, #endif NULL }; /* Return a list of comma-separated names of supported encodings. */ char *Curl_all_content_encodings(void) { size_t len = 0; const struct content_encoding * const *cep; const struct content_encoding *ce; char *ace; for(cep = encodings; *cep; cep++) { ce = *cep; if(!strcasecompare(ce->name, CONTENT_ENCODING_DEFAULT)) len += strlen(ce->name) + 2; } if(!len) return strdup(CONTENT_ENCODING_DEFAULT); ace = malloc(len); if(ace) { char *p = ace; for(cep = encodings; *cep; cep++) { ce = *cep; if(!strcasecompare(ce->name, CONTENT_ENCODING_DEFAULT)) { strcpy(p, ce->name); p += strlen(p); *p++ = ','; *p++ = ' '; } } p[-2] = '\0'; } return ace; } /* Real client writer: no downstream. */ static CURLcode client_init_writer(struct Curl_easy *data, struct contenc_writer *writer) { (void) data; return writer->downstream? CURLE_WRITE_ERROR: CURLE_OK; } static CURLcode client_unencode_write(struct Curl_easy *data, struct contenc_writer *writer, const char *buf, size_t nbytes) { struct SingleRequest *k = &data->req; (void) writer; if(!nbytes || k->ignorebody) return CURLE_OK; return Curl_client_write(data, CLIENTWRITE_BODY, (char *) buf, nbytes); } static void client_close_writer(struct Curl_easy *data, struct contenc_writer *writer) { (void) data; (void) writer; } static const struct content_encoding client_encoding = { NULL, NULL, client_init_writer, client_unencode_write, client_close_writer, sizeof(struct contenc_writer) }; /* Deferred error dummy writer. */ static CURLcode error_init_writer(struct Curl_easy *data, struct contenc_writer *writer) { (void) data; return writer->downstream? CURLE_OK: CURLE_WRITE_ERROR; } static CURLcode error_unencode_write(struct Curl_easy *data, struct contenc_writer *writer, const char *buf, size_t nbytes) { char *all = Curl_all_content_encodings(); (void) writer; (void) buf; (void) nbytes; if(!all) return CURLE_OUT_OF_MEMORY; failf(data, "Unrecognized content encoding type. " "libcurl understands %s content encodings.", all); free(all); return CURLE_BAD_CONTENT_ENCODING; } static void error_close_writer(struct Curl_easy *data, struct contenc_writer *writer) { (void) data; (void) writer; } static const struct content_encoding error_encoding = { NULL, NULL, error_init_writer, error_unencode_write, error_close_writer, sizeof(struct contenc_writer) }; /* Create an unencoding writer stage using the given handler. */ static struct contenc_writer * new_unencoding_writer(struct Curl_easy *data, const struct content_encoding *handler, struct contenc_writer *downstream, int order) { struct contenc_writer *writer; DEBUGASSERT(handler->writersize >= sizeof(struct contenc_writer)); writer = (struct contenc_writer *) calloc(1, handler->writersize); if(writer) { writer->handler = handler; writer->downstream = downstream; writer->order = order; if(handler->init_writer(data, writer)) { free(writer); writer = NULL; } } return writer; } /* Write data using an unencoding writer stack. "nbytes" is not allowed to be 0. */ CURLcode Curl_unencode_write(struct Curl_easy *data, struct contenc_writer *writer, const char *buf, size_t nbytes) { if(!nbytes) return CURLE_OK; return writer->handler->unencode_write(data, writer, buf, nbytes); } /* Close and clean-up the connection's writer stack. */ void Curl_unencode_cleanup(struct Curl_easy *data) { struct SingleRequest *k = &data->req; struct contenc_writer *writer = k->writer_stack; while(writer) { k->writer_stack = writer->downstream; writer->handler->close_writer(data, writer); free(writer); writer = k->writer_stack; } } /* Find the content encoding by name. */ static const struct content_encoding *find_encoding(const char *name, size_t len) { const struct content_encoding * const *cep; for(cep = encodings; *cep; cep++) { const struct content_encoding *ce = *cep; if((strncasecompare(name, ce->name, len) && !ce->name[len]) || (ce->alias && strncasecompare(name, ce->alias, len) && !ce->alias[len])) return ce; } return NULL; } /* allow no more than 5 "chained" compression steps */ #define MAX_ENCODE_STACK 5 /* Set-up the unencoding stack from the Content-Encoding header value. * See RFC 7231 section 3.1.2.2. */ CURLcode Curl_build_unencoding_stack(struct Curl_easy *data, const char *enclist, int is_transfer) { struct SingleRequest *k = &data->req; unsigned int order = is_transfer? 2: 1; do { const char *name; size_t namelen; /* Parse a single encoding name. */ while(ISBLANK(*enclist) || *enclist == ',') enclist++; name = enclist; for(namelen = 0; *enclist && *enclist != ','; enclist++) if(!ISSPACE(*enclist)) namelen = enclist - name + 1; /* Special case: chunked encoding is handled at the reader level. */ if(is_transfer && namelen == 7 && strncasecompare(name, "chunked", 7)) { k->chunk = TRUE; /* chunks coming our way. */ Curl_httpchunk_init(data); /* init our chunky engine. */ } else if(namelen) { const struct content_encoding *encoding = find_encoding(name, namelen); struct contenc_writer *writer; if(!k->writer_stack) { k->writer_stack = new_unencoding_writer(data, &client_encoding, NULL, 0); if(!k->writer_stack) return CURLE_OUT_OF_MEMORY; } if(!encoding) encoding = &error_encoding; /* Defer error at stack use. */ if(k->writer_stack_depth++ >= MAX_ENCODE_STACK) { failf(data, "Reject response due to more than %u content encodings", MAX_ENCODE_STACK); return CURLE_BAD_CONTENT_ENCODING; } /* Stack the unencoding stage. */ if(order >= k->writer_stack->order) { writer = new_unencoding_writer(data, encoding, k->writer_stack, order); if(!writer) return CURLE_OUT_OF_MEMORY; k->writer_stack = writer; } else { struct contenc_writer *w = k->writer_stack; while(w->downstream && order < w->downstream->order) w = w->downstream; writer = new_unencoding_writer(data, encoding, w->downstream, order); if(!writer) return CURLE_OUT_OF_MEMORY; w->downstream = writer; } } } while(*enclist); return CURLE_OK; } #else /* Stubs for builds without HTTP. */ CURLcode Curl_build_unencoding_stack(struct Curl_easy *data, const char *enclist, int is_transfer) { (void) data; (void) enclist; (void) is_transfer; return CURLE_NOT_BUILT_IN; } CURLcode Curl_unencode_write(struct Curl_easy *data, struct contenc_writer *writer, const char *buf, size_t nbytes) { (void) data; (void) writer; (void) buf; (void) nbytes; return CURLE_NOT_BUILT_IN; } void Curl_unencode_cleanup(struct Curl_easy *data) { (void) data; } char *Curl_all_content_encodings(void) { return strdup(CONTENT_ENCODING_DEFAULT); /* Satisfy caller. */ } #endif /* CURL_DISABLE_HTTP */ 但是patch的行数对不上，那要如何修复？可不可以修复？
最新发布
09-12
<think> 我们面临的问题：有一个patch文件，它基于某个版本的curl源码（commit 76f83f0db23846e254d940ec7fe141010077eb88）生成，目的是移除对旧版zlib（1.2.0.4之前）的支持。 但是，我们手头的源码（以压缩包...
PHP4用户手册:函数->CURL->curl_setopt
02-05 1060
curl_setopt(PHP 4 >= 4.0.2)curl_setopt -- 为CURL调用设置一个选项 描述　bool curl_setopt (int ch, string option, mixed value)　curl_setopt()函数将为一个CURL会话设置选项。option参数是你想要的设置，value是这个选项给定的
PHP4用户手册:函数->fseek
02-05 900
fseek(PHP 3, PHP 4 >= 4.0.0)fseek -- 定位一个文件的指针描述int fseek (int fp, int offset [, int whence])为这个文件的引用fp设置文件指示器。这个新的位置，是从文件开始以字节为标准由offset指定的，或由 whence指定的位置开始。 whence的值见下： S
PHP4用户手册:函数->trim
02-05 868
trim(PHP 3, PHP 4 >= 4.0.0)trim -- 去除一个字符串开始和结尾的空白 描述string trim (string str [, string charlist])注意：第二个参数用在PHP 4.1.0 这个函数返回str字符串被去除首尾空白后的新字符串。不带第二个参数trim() 将去除下列字符：
PHP4用户手册:函数->usleep
02-05 844
usleep(PHP 3, PHP 4 >= 4.0.0)usleep -- 暂停执行多少毫秒描述void usleep (int micro_seconds)usleep() 函数暂停程序执行由 micro_seconds指定的毫秒数 参见 sleep(). 注意：这个函数不能工作在 Windows 操作系统中。
PHP4用户手册:函数->flock
02-05 842
flock(PHP 3>= 3.0.7, PHP 4 >= 4.0.0)flock -- 锁定文件描述bool flock (int fp, int operation [, int wouldblock])PHP 支持在访问文件时完全的锁定文件(这意味着所有的访问程序不得不使用相同的锁定方式，或者它不工作）。 flock() 运行在打开的文件指针fp之上。
PHP4用户手册:函数->fopen
02-05 841
fopen(PHP 3, PHP 4 >= 4.0.0)fopen -- 打开文件或URL描述int fopen (string filename, string mode [, int use_include_path])如果filename 以"http://"开始 (大小写不敏感), 则本函数用HTTP 1.0连接打开指定的服务器，这个页面被使用HTTP　
PHP4用户手册:函数->CURL->curl_exec
02-05 831
curl_exec(PHP 4 >= 4.0.2)curl_exec -- 执行一个CURL会话 描述　bool curl_exec (int ch)　在你初始化一个CURL会话，及为这个会话设置了所有的选项后，这个函数将被调用。它的目的仅仅是执行预先确定的CURL会话(通过给定的ch参数)。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值