使用CURL实现http文件下载加一个多任务的封装.

最新推荐文章于 2023-12-15 10:04:16 发布
最新推荐文章于 2023-12-15 10:04:16 发布
阅读量122 收藏
点赞数
原文链接：http://www.cnblogs.com/freezee/archive/2012/04/19/2457851.html
版权

What I write, what I lose.

Mark下. 

主要是使用CURL实现http文件下载, 

在此基础上做一个多任务的封装. 附带md5检测.

 
头文件: 
#define HTTPTASKE_OK            0
#define HTTPTASKE_ERROR         1

#define TASKID                  int

typedef enum
{
    STATUS_BASE                     = 0,

    STATUS_IDLE,
    STATUS_RUNNING, 
    STATUS_FINISHED_OK,
    STATUS_FINISHED_ERROR,
}HttpTaskStatus_e;


int httptask_init(void);
int httptask_deinit(void);

int httptask_addfiletask(const char* url_s, int timeout_s, 
        const char* filename_s, 
        const char* checkmd5sum_s, long checksize_s);
int httptask_addbuffertask(const char* url_s, int timeout_s, 
        char* buffer_s, long size_buffer_s, 
        const char* checkmd5sum_s, long checksize_s);

int httptask_run(void);
int httptask_asynrun(void);

int httptask_getitemstatus(int i, HttpTaskStatus_e* status_e, int* percent);
int httptask_getstatus(HttpTaskStatus_e* status_e, int* percent);

　　实现文件:

#include <stdio.h>
#include <string.h>
#include <pthread.h>

#include "common_debug.inc.h"
#include "curl/curl.h"
#include "httptask.h"
#include "md5chk.h"

#define u_strcpy(dest, len, src) strncpy(dest, src, len-1)

#define HTTPTASK_LEN_URL        1024
#define HTTPTASK_LEN_FILENAME   1024
#define HTTPTASK_LEN_MD5SUM     36
#define HTTPTASK_LEN_MD5        20
#define HTTPTASK_NUM_MAXTASK    10


struct _HttpTaskItem
{
    //
    char url[HTTPTASK_LEN_URL];
    int timeout;

    char filename[HTTPTASK_LEN_FILENAME];
    bool filemode;

    char* buffer;
    long size_buffer;

    //
    char check_md5sum[HTTPTASK_LEN_MD5SUM];
    long check_size;

    //
    double dltotal;
    double dlnow;
    FILE* fp;
    long index_buffer;

    //md5 count about.
    MD5_CTX md5ctx;
    unsigned char md5ori[HTTPTASK_LEN_MD5];
    size_t dlcount;

    //Status about.
    HttpTaskStatus_e item_status_e;
    double percent;
    double base_percent;
};
typedef struct _HttpTaskItem HttpTaskItem;


struct _HttpTaskItemSet
{
    int num;
    HttpTaskItem httptask[HTTPTASK_NUM_MAXTASK];
    
    HttpTaskStatus_e status_e;
    double percent;
};
typedef struct _HttpTaskItemSet HttpTaskItemSet;

HttpTaskItemSet gs_httptaskset = {0};


int httptask_init(void)
{
    int ret = HTTPTASKE_OK;

    HttpTaskItemSet* httptaskset = &gs_httptaskset;
    httptaskset->num = 0;
    int i = 0;
    for(i=0; i<HTTPTASK_NUM_MAXTASK; i++)
    {
        HttpTaskItem* httptask = &(httptaskset->httptask[i]);
        httptask = httptask; 
        //httptaskitem_init(httptask);
    }
    memset(httptaskset, 0, sizeof(HttpTaskItemSet));

    httptaskset->status_e = STATUS_IDLE;

    return ret;
}


int httptask_deinit(void)
{
    int ret = HTTPTASKE_OK;

    HttpTaskItemSet* httptaskset = &gs_httptaskset;
    httptaskset->num = 0;
    int i = 0;
    for(i=0; i<HTTPTASK_NUM_MAXTASK; i++)
    {
        HttpTaskItem* httptask = &(httptaskset->httptask[i]);
        httptask = httptask; 
        //httptaskitem_deinit(httptask);
    }
    memset(httptaskset, 0, sizeof(HttpTaskItemSet));

    httptaskset->status_e = STATUS_IDLE;

    return ret;
}


int httptask_addfiletask(const char* url_s, int timeout_s, 
        const char* filename_s, 
        const char* checkmd5sum_s, long checksize_s)
{
    int ret = HTTPTASKE_OK;

    HttpTaskItemSet* httptaskset = &gs_httptaskset;
    int index = httptaskset->num;
    if(index >= HTTPTASK_NUM_MAXTASK)
    {
        DBGPRINTF_ERROR("Add File task error.\n");
        ret = HTTPTASKE_ERROR;
        return ret;
    }
    (httptaskset->num) ++ ;
    HttpTaskItem* httptask = &(httptaskset->httptask[index]);
    u_strcpy(httptask->url, HTTPTASK_LEN_URL, url_s);
    httptask->timeout = timeout_s;
    httptask->filemode = false;
    u_strcpy(httptask->filename, HTTPTASK_LEN_FILENAME, filename_s);
    httptask->filemode = true;
    
    if(checkmd5sum_s != NULL)
    {
        u_strcpy(httptask->check_md5sum, HTTPTASK_LEN_MD5SUM, checkmd5sum_s);
    }
    httptask->check_size = checksize_s;

    httptask->item_status_e = STATUS_IDLE;
    httptask->percent = -1;

    DBGPRINTF_DEBUG("Add File task OK.\n");    

    return ret;
}


int httptask_addbuffertask(const char* url_s, int timeout_s, 
        char* buffer_s, long size_buffer_s, 
        const char* checkmd5sum_s, long checksize_s)
{
    int ret = HTTPTASKE_OK;

    HttpTaskItemSet* httptaskset = &gs_httptaskset;
    int index = httptaskset->num;
    if(index >= HTTPTASK_NUM_MAXTASK)
    {
        DBGPRINTF_ERROR("Add File task error.\n");
        ret = HTTPTASKE_ERROR;
        return ret;
    }
    (httptaskset->num) ++ ;
    HttpTaskItem* httptask = &(httptaskset->httptask[index]);
    u_strcpy(httptask->url, HTTPTASK_LEN_URL, url_s);
    httptask->timeout = timeout_s;
    httptask->filemode = false;
    httptask->buffer = buffer_s;
    httptask->size_buffer = size_buffer_s;    

    if(checkmd5sum_s != NULL)
    {
        u_strcpy(httptask->check_md5sum, HTTPTASK_LEN_MD5SUM, checkmd5sum_s);
    }
    httptask->check_size = checksize_s;

    httptask->item_status_e = STATUS_IDLE;
    httptask->percent = -1;

    DBGPRINTF_DEBUG("Add Buffer task OK.\n");    

    return ret;
}


static int httptask_perform(HttpTaskItemSet* httptaskset);


int httptask_run(void)
{
    int ret = HTTPTASKE_OK;

    DBGPRINTF_INFO("HttpTask run.\n");

    HttpTaskItemSet* httptaskset = &(gs_httptaskset);
    ret = httptask_perform(httptaskset);

    DBGPRINTF_INFO("HttpTask run finished.\n");

    return ret;
}


void* func_httptaskperform(void* arg)
{
    HttpTaskItemSet* httptaskset = (HttpTaskItemSet*)arg;
    httptask_perform(httptaskset); 

    return NULL;
}


int httptask_asynrun(void)
{
    int ret = HTTPTASKE_OK;

    DBGPRINTF_INFO("HttpTask Asyn run.\n");

    HttpTaskItemSet* httptaskset = &(gs_httptaskset);

    pthread_t pid;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    int ret_pthread = pthread_create(&pid, &attr, func_httptaskperform, httptaskset);
    if(ret_pthread != 0)
    {
        DBGPRINTF_ERROR("HttpTask : AsyncRun create pthread error.\n");
        ret = HTTPTASKE_ERROR;
    }

    DBGPRINTF_INFO("HttpTask Asyn run finished.\n");

    return ret;
}


int httptask_getitemstatus(int i, HttpTaskStatus_e* status_e, int* percent)
{
    int ret = HTTPTASKE_OK;

    HttpTaskItemSet* httptaskset = &(gs_httptaskset);
    HttpTaskItem* httptask = &(httptaskset->httptask[i]);
    *status_e = httptask->item_status_e;
    *percent = (httptask->percent>=0.0)?(int)(httptask->percent * 100.0 + 0.5):-1;

    return ret;
}


int httptask_getstatus(HttpTaskStatus_e* status_e, int* percent)
{
    int ret = HTTPTASKE_OK;

    HttpTaskItemSet* httptaskset = &(gs_httptaskset);
    *status_e = httptaskset->status_e;
    *percent = (httptaskset->percent>=0.0)?(int)(httptaskset->percent * 100.0 + 0.5):-1;

    return ret;
}


static size_t HttpWriteContentToFp(char *buffer, size_t size, size_t nitems, void *outstream);
static size_t HttpWriteContentToBuffer(char *buffer, size_t size, size_t nitems, void *outstream);
static int WriteProgress(void* p, double dltotal, double dlnow, double ultotal,double ulnow);

int httptask_countbasepercent(HttpTaskItemSet* httptaskset);
int httptaskitem_addrecvedsize(HttpTaskItem* httptask, size_t size_recv);
int httptaskitem_updatepercent(HttpTaskItem* httptask, double percent);

int httptask_perform(HttpTaskItemSet* httptaskset)
{
    int ret = HTTPTASKE_OK;

    DBGPRINTF_DEBUG("HttpTask perform.\n");

    httptask_countbasepercent(httptaskset);

    httptaskset->status_e = STATUS_RUNNING;
    int i = 0;
    bool finishedok = true;
    for(i=0; i<httptaskset->num; i++)
    {
        DBGPRINTF_DEBUG("HttpTask perform : %d.\n", i+1);

        HttpTaskItem* httptask = &(httptaskset->httptask[i]);
        httptask->item_status_e = STATUS_RUNNING;
        httptask->percent = 0.0;

        httptask->dlcount = 0;

        //Count md5.
        if((httptask->check_md5sum!=NULL) && (strlen(httptask->check_md5sum)>0)) 
        {
            MD5Init(&(httptask->md5ctx));
        }
    
        //Create CURL handle.
        CURLcode ret_curl = CURLE_OK;
		CURL* curl = curl_easy_init();
        if(curl == NULL)
        {
            DBGPRINTF_ERROR("curl_easy_init error.\n");
            httptask->item_status_e = STATUS_FINISHED_ERROR;
            finishedok = false;
            break;
        }
            
        /*Set url.*/
        curl_easy_setopt(curl, CURLOPT_URL, httptask->url);
        /*Timeout set.*/
        if(httptask->timeout > 0)
        {
            curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
            curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, httptask->timeout);
            curl_easy_setopt(curl, CURLOPT_TIMEOUT, httptask->timeout);
        }

        /*Low speed.*/
        curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 1L);
        curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, 20L);

        /*Set debug on.*/
        #ifdef HTTPPT_DEBUG
        curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
        #endif

        /*Set progress.*/
        curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
        curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, WriteProgress);
        curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, httptask);

        /*Set callback.*/
        //鍖哄垎璁剧疆 鍐機ontent 鍒版枃浠?or 鍒癰uffer.
        if(httptask->filemode)
        {      
            FILE* fp = fopen(httptask->filename, "w");
            if(fp == NULL)
            {
                DBGPRINTF_ERROR("Open file to write failed.[%s].\n", httptask->filename);
                httptask->item_status_e = STATUS_FINISHED_ERROR;
                finishedok = false;
                /* always cleanup */ 
                curl_easy_cleanup(curl);
                break;
            }
            httptask->fp = fp;
            curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, HttpWriteContentToFp);
        }
        else
        {
            httptask->index_buffer = 0;
            curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, HttpWriteContentToBuffer);
        }
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, httptask);
         
        /* Perform the request, res will get the return code */ 
        ret_curl = curl_easy_perform(curl);

        if((httptask->filemode) && (httptask->fp != NULL))
        {
            fclose(httptask->fp);
            httptask->fp = NULL;
        }
        
        /* always cleanup */ 
        curl_easy_cleanup(curl);

        /* Check return value after curl_easy_perform. */
        if(ret_curl != CURLE_OK)
        {
            DBGPRINTF_ERROR("[CURL]%s.\n", curl_easy_strerror(ret_curl));
            httptask->item_status_e = STATUS_FINISHED_ERROR;
            finishedok = false;
            break;
        }

        /*Check md5 checksum.*/
        if((httptask->check_md5sum!=NULL) && (strlen(httptask->check_md5sum)>0)) 
        {
            MD5Final(httptask->md5ori, &(httptask->md5ctx));
            char count_md5sum[HTTPTASK_LEN_MD5SUM] = {0};
            int i = 0;
            char tmp[4] = {0};
            for(i=0; i<16; i++)
            {
                memset(tmp, 0, 4);
                snprintf(tmp, 4, "%02x", httptask->md5ori[i]);
                memcpy(count_md5sum+i*2, tmp, 2);
            }
            DBGPRINTF_DEBUG("count_md5sum=%s.\n", count_md5sum);
            DBGPRINTF_DEBUG("check_md5sum=%s.\n", httptask->check_md5sum);

            if(strcasecmp(httptask->check_md5sum, count_md5sum) == 0)
            {
                DBGPRINTF_DEBUG("Md5 check OK.\n");
            }
            else
            {
                DBGPRINTF_ERROR("Md5 check ERROR.\n");
                httptask->item_status_e = STATUS_FINISHED_ERROR;
                finishedok = false;
                break;
            }
        }

        /*Check downloaded size.*/
        if(httptask->check_size!=0) 
        {
            size_t dlcount          = (size_t)(httptask->dlcount);
            size_t check_size       = (size_t)(httptask->check_size);
            size_t dlnow            = (size_t)(httptask->dlnow);
            size_t dltotal          = (size_t)(httptask->dltotal);

            if( (dltotal != 0) && 
                !( (dlcount==check_size) && (dlnow==dltotal) && (dlnow==dlcount) ) )
            {
                DBGPRINTF_ERROR("Size check ERROR., [checksize:%ld, dlcount:%u, dlnow:%lf, dltotal:%lf].\n", 
                        httptask->check_size, httptask->dlcount, httptask->dlnow, httptask->dltotal);
                httptask->item_status_e = STATUS_FINISHED_ERROR;
                finishedok = false;
                break;
            }
                
            if( (httptask->dltotal == 0) && 
                !( (dlcount==check_size) && (dlnow==dlcount) ) )
            {
                DBGPRINTF_ERROR("Size check ERROR., [checksize:%ld, dlcount:%u, dlnow:%lf, dltotal:%lf].\n", 
                        httptask->check_size, httptask->dlcount, httptask->dlnow, httptask->dltotal);
                httptask->item_status_e = STATUS_FINISHED_ERROR;
                finishedok = false;
                break;
            }
        }
        
        httptask->percent = 1;    
    }

    httptaskset->status_e = finishedok?STATUS_FINISHED_OK:STATUS_FINISHED_ERROR;

    return ret;
}


size_t HttpWriteContentToFp(char *buffer, size_t size, size_t nitems, void *outstream)
{
    HttpTaskItem* httptask = (HttpTaskItem*)outstream;

	//DBGPRINTF_DEBUG("Receive data : %u .\n", nitems);
	FILE* fp = httptask->fp;
	size_t size_recv = fwrite(buffer, size, nitems, fp);
	httptask->dlcount += size_recv;
    httptaskitem_addrecvedsize(httptask, size_recv);

    //Count md5.
    if((httptask->check_md5sum!=NULL) && (strlen(httptask->check_md5sum)>0) && (size_recv > 0))
    {
        MD5Update(&(httptask->md5ctx), (unsigned char*)buffer, size_recv);
    }
    
    return size_recv;
}


size_t HttpWriteContentToBuffer(char *buffer, size_t size, size_t nitems, void *outstream)
{
    HttpTaskItem* httptask = (HttpTaskItem*)outstream;

	//DBGPRINTF_DEBUG("Receive data : %u .\n", nitems);
	long* index = &(httptask->index_buffer);
    size_t size_recv = 0;
    if((long)(size*nitems) <= httptask->size_buffer - *index)
    {
	    size_recv = size*nitems;
        memcpy(httptask->buffer + *index, buffer, size*nitems);
        *index += size*nitems;
    }
    else
    {
        DBGPRINTF_ERROR("Buffer not enought to store downloaded content.\n");
        size_recv = 0 ;
    }

	httptask->dlcount += size_recv;
    httptaskitem_addrecvedsize(httptask, size_recv);
    
    //Count md5.
    if((httptask->check_md5sum!=NULL) && (strlen(httptask->check_md5sum)>0) && (size_recv > 0))
    {
        MD5Update(&(httptask->md5ctx), (unsigned char*)buffer, size_recv);
    }
    
    return size_recv;
}


int WriteProgress(void* p, double dltotal, double dlnow, double ultotal,double ulnow)
{
    HttpTaskItem* httptask = (HttpTaskItem*)p;

	//DBGPRINTF_DEBUG("WriteProgress : %lf, %lf .\n", dlnow, dltotal);
	httptask->dltotal = dltotal;
	httptask->dlnow = dlnow;

    if((httptask->dlnow > 0) && (httptask->dlnow != -1))
    {
        //double pre_percent = httptask->percent;
        httptask->percent = httptask->dlnow / httptask->dltotal;
        //double add_percent = httptask->percent - pre_percent;
        httptaskitem_updatepercent(httptask, httptask->percent);
    }
    
	return 0;
}


int httptaskitem_addrecvedsize(HttpTaskItem* httptask, size_t size_recv)
{
    int ret = HTTPTASKE_OK;


    return ret;
}


int httptaskitem_updatepercent(HttpTaskItem* httptask, double percent)
{
    int ret = HTTPTASKE_OK;
    percent = percent;
    HttpTaskItemSet* httptaskset = &gs_httptaskset;
    httptaskset->percent = 0.0;
    int i = 0;
    for(i=0; i<httptaskset->num; i++)
    {
        HttpTaskItem* httptask = &(httptaskset->httptask[i]);
        if(httptask->percent>=0.0)
        {
            httptaskset->percent += httptask->percent * httptask->base_percent ;
        }
    }
    
    return ret;
}


int httptask_countbasepercent(HttpTaskItemSet* httptaskset)
{
    int ret = HTTPTASKE_OK;

    int i = 0;
    bool sizeset = true;
    long totalsize = 0;
    for(i=0; i<httptaskset->num; i++)
    {
        HttpTaskItem* httptask = &(httptaskset->httptask[i]);
        if(httptask->check_size <= 0)
        {
            sizeset = false;
            break;
        }
        totalsize += httptask->check_size;
    }

    for(i=0; i<httptaskset->num; i++)
    {
        HttpTaskItem* httptask = &(httptaskset->httptask[i]);
        httptask->percent = 0;
        if(sizeset)
        {
            httptask->base_percent = double(httptask->check_size) / double(totalsize);
        }
        else
        {
            httptask->base_percent = 1 / httptaskset->num;
        }
    }

    return ret;
}

　　

转载于:https://www.cnblogs.com/freezee/archive/2012/04/19/2457851.html

weixin_30684743
关注
第09课：基于 Etcd 的分布式锁实现原理及方案
Jin_Kwok的博客
10-28 1189
Etcd 最新版本已经提供了支持分布式锁的基础接口（可见官网说明），但本文并不局限于此。 本文将介绍两条实现分布式锁的技术路线： 从分布式锁的原理出发，结合 Etcd 的特性，洞见分布式锁的实现细节； 基于 Etcd 提供的分布式锁基础接口进行封装，实现分布式锁。 两条路线差距甚远，建议读者先看路线 1，以便了解 Etcd 实现分布式锁的细节。 1. 为什么选择 Etcd 据官网介绍，Etcd...
Android开源经典项目
Tamic （大白）
09-13 5748
Android开源项目大全，包括经典个人博客，组织和开源项目
PHP使用CURL实现下载文件功能示例
10-16
主要介绍了PHP使用CURL实现下载文件功能,结合具体实例形式分析了php基于curl的文件下载实现技巧,代码注释有详细的功能说明,并附带了curl参数的功能讲解,需要的朋友可以参考下
使用libcurl实现的下载器
RobertBaker的专栏
02-10 4472
libcurl的主页：http://curl.haxx.se/ 头文件： /********************************************************************** * Copyright (C) 2014 -  - All Rights Reserved * * 文件名称:        Downloader_LibCurl.
使用curl静态库-http下载功能
chlaws的专栏
07-15 2770
下载 curl-7.19.0 http://curl.haxx.se/download/curl-7.19.0.tar.bz2打开DSW项目文件，作如下设定定义宏 HTTP_ONLY (否则会出现LDAP没有类库的问题)Build 就会生成出来curllib.lib (可在属性中
curl 命令的使用：HTTP请求、下载文件、FTP上传下载
clvert的博客
11-15 5192
cURL（CommandLine Uniform Resource Locator），是一个利用 URL 语法，在命令行终端下使用的网络请求工具，支持 HTTP、HTTPS、FTP 等协议。cURL 也有用于程序开发使用的版本 libcurl。Linux、MAC 一般系统默认已安装好 curl，直接在终端使用命令即可，如果需要手动安装，可以到 curl.haxx.se 下载安装。
C++ 使用 curl 进行 http 请求（GET、POST、Download）的封装
weixin_34319640的博客
08-14 755
修改自网路   CommonTools.h   /* * CommonTools.h * * Created on: 2018年8月2日 * Author: didi */ #include &lt;iostream&gt; #include &lt;curl/curl.h&gt; #include "zlib.h" #include &lt;vector&gt; #in...
基于curl的异步http实现
热门推荐
baihacker的专栏
07-03 2万+
简述用于windows客户端的一个异步http模块的实现 1.需要实现的feature 1.1 很容易地发起异步http请求，然后回调。 1.2 能够管理http并发数。 1.3 能够支持http超时：不依赖于curl中实现的连接超时及其它超时。 1.4 请求可以取消。 2.参与者和简要分析： Manager：接收http请求，调用curl。 Request：封装htt
【微服务】Etcd实现服务器注册和发现|Etcd、Eureka、Consul、Zookeeper 比较
小鱼菜鸟的博客
08-19 438
目录 Etcd、Eureka、Consul、Zookeeper 的比较 Etcd 服务注册与发现的必要： etcd简介 etcd分布式一致性算法 etcd应用场景 etcd安装 服务注册与发现实例(go语言) 服务注册的简单实现1： 服务注册的简单实现2： 都是key-value存储，redis 可以代替 etcd吗？ 为什么选择...
2020-04 前端技术汇总
鲨了泥的博客
06-10 1698
2020/04/29 周三 #UI设计视觉差问题，总感觉没有居中对齐时怎么办 放大n倍，截图画框，看是否在一条水平线上。 关于UI设计视觉差相关知识点 测量面积和视觉面积 视觉体量是人眼如何察觉物体的大小和感觉，不需要等同于物体的实际像素值 圆、菱形、三角形和其他非方形形状为了与方形形状保持一样的视觉大小，应适当放大 图标区域应为视觉平衡保留一定的空间，这一点对保持同系列图标视觉平衡很重要。(这也是iconfont上为什么有的图标周围有留白，而有的图标没有留白的原因) 不同形状之间的对齐 具有锐利边缘
利用libcurl进行http下载
11-24
利用libcurl开源库进行http下载 带注释
CUrlHttp封装curl类
07-21
CUrlHttp类是根据curl库提供的接口。支持get、post、表单提交方式请求
curl库做http请求
09-29
curl库做HTTP请求，安卓的。curl库做HTTP请求，安卓的。
CURL 是什么
ChasingdreamLY的博客
05-08 8844
cURL是一个利用URL语法在命令行下工作的文件传输工具，1997年首次发行。 它支持文件上传和下载，所以是综合传输工具，但按传统，习惯称cURL为下载工具。 cURL还包含了用于程序开发的libcurl。cURL支持的通信协议有FTP、FTPS、HTTP、HTTPS、TFTP、SFTP、Gopher、SCP、Telnet、DICT、FILE、LDAP、LDAPS、IMAP、POP3、SMTP和
curl 执行php,php中使用Curl多进程多任务执行
weixin_29109553的博客
03-10 489
php的扩展库-Curl，通常是默认在安装包中，你可以用它获取其他网页的内容，也可以用它做点别。查看phpinfo()，如果curlsprotenabled则表示支持curl库。开启curl库支持：1、windows下开启curl库支持：打开php.ini，将extension=php_curl.dll前的;号去掉。2、linux下php开启curl库支持：编译PHP时在./configu...
用curl或wget下载文件
最新发布
闲人的专栏
12-15 3084
curl -O是一个常用的 curl 命令，它用于将远程文件下载到当前工作目录，并使用该文件的原始名称保存到本地。其中-O参数是大写字母 O，表示从 URL 中提取文件名并使用该文件名保存到本地。使用-o参数可以将下载的文件保存到本地，其中-o参数后指定要保存的文件名，是文件的下载地址。大写字母 O，表示从 URL 中提取文件名并使用该文件名保存到本地。这会将文件的内容直接输出到终端，可以使用等符号将其导出到文件中。curl可以直接使用代理或用环境变量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值