使用libcurl显示下载进度

（1）s_get_download_file_length函数获取目标文件大小。

（2）进度条处理函数CURLOPT_PROGRESSFUNCTION，注意设置的回调函数不要忘记了正常情况下return 0;否则将会导致回调异常。

/*********************
ftp_down_load.c
**********************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#include <curl/curl.h>
#include <curl/curl.h>

#define UserNameMaxLen 100
#define PasswordMaxLen 50
#define UrlMaxLen 1024

#define DesFileName "/share/binxu.rmvb"
#define FtpUrl "ftp://192.168.1.102/binxu.rmvb"

typedef struct ftp_init_param_s
{
	int dumy;
}ftp_init_param_t;

typedef struct ftp_connect_param_s
{
	char chUserName[UserNameMaxLen];
	char chPassword[PasswordMaxLen];
	char chUrl[UrlMaxLen];
	char chUserPwd[UserNameMaxLen+PasswordMaxLen];
}ftp_connect_param_t;

typedef struct ftp_file_s
{
  const char *pchFilename;
  FILE *stream;
  double nFileLength;
  double nCount;
  unsigned int nPersent;
}ftp_file_t;

void main_ftp_download_test();

int ftp_download(ftp_connect_param_t * pstuFtpConnectParam,ftp_file_t *pstuFtpFile);


int ftp_init(void *param);

int s_curl_init();

int s_curl_term();

double s_get_download_file_length(ftp_connect_param_t * pstuFtpConnectParam);

void set_ftp_file(ftp_file_t *pstuFtpFile, char *pchFileName);

void set_ftp_connect_param(ftp_connect_param_t * pstuFtpConnectParam);

int main()
{
	main_ftp_download_test();
	return 0;
}
void main_ftp_download_test()
{
	ftp_init_param_t pstuInitParam;
	ftp_file_t stuFtpFile;
	ftp_connect_param_t stuFtpConnectParam;
	
	memset(&pstuInitParam, 0, sizeof(ftp_init_param_t));
	if(0 != ftp_init(&pstuInitParam))
	{
		printf("\n ftp_init error \n");
		return;
	};

	memset(&stuFtpConnectParam, 0, sizeof(ftp_connect_param_t));
	set_ftp_connect_param(&stuFtpConnectParam);
	
	memset(&stuFtpFile, 0, sizeof(ftp_file_t));
	set_ftp_file(&stuFtpFile, DesFileName);

	stuFtpFile.nFileLength = s_get_download_file_length(&stuFtpConnectParam);
	if(-1 == stuFtpFile.nFileLength)
	{
		printf("\n s_get_download_file_length error \n");
		return;
	}

	printf("\n#####  file len = %lf #####\n",stuFtpFile.nFileLength);

	//int ftp_download(ftp_connect_param_t * pstuFtpConnectParam,ftp_file_t *pstuFtpFile)

    ftp_download(&stuFtpConnectParam,&stuFtpFile);

	printf("\nstuFtpFile.ncount[%lf]\n",stuFtpFile.nCount);
	if(stuFtpFile.stream)
	{ 
		fclose(stuFtpFile.stream); /* close the local file */
	}
	
	s_curl_term();
  
}

static size_t my_fwrite(void *buffer, size_t size, size_t nmemb,
                        void *stream)
{
	ftp_file_t *out = (ftp_file_t *)stream;
	static int iFlag = 0;
	static int i = 0;
	if(!out)
	{
		return -1;
	}
	//printf("\n %d \n",size*nmemb);

	if(!out->stream)
	{
		/* open file for writing */
		out->stream=fopen(out->pchFilename, "wb");
		if(!out->stream)
		{
			return -1; /* failure, can't open file to write */
		}
	}

	out->nCount += size*nmemb;
	
	return fwrite(buffer, size, nmemb, out->stream);
}

//int progress_callback(void *clientp,   double dltotal,   double dlnow,   double ultotal,   double ulnow);
int my_progress_callback(void *clientp,   double dltotal,   double dlnow,   double ultotal,   double ulnow)
{
	static int i=0;
	i++;
	if(i%10000==0 && dltotal > 0)
	{
	   //printf("\n dltotal[%03lf] dlnow[%03lf] ultotal[%03lf] ulnow[%03lf]",dltotal,dlnow,ultotal,ulnow);
		int nPersent = (int)(100.0*dlnow/dltotal);
	    printf("\n persent[%d%]",nPersent);
	}	
	return 0;
	
}

int ftp_download(ftp_connect_param_t * pstuFtpConnectParam,ftp_file_t *pstuFtpFile)
{
	CURLcode res;
	CURL *p_curl_handle = NULL;
	
	if((NULL == pstuFtpConnectParam)
		|| (NULL == pstuFtpFile)
		|| (0 == strlen(pstuFtpConnectParam->chUrl))
		|| (0 == strlen(pstuFtpConnectParam->chUserPwd)))
	{
		printf("\n param error \n");
		return -1;
	}

	p_curl_handle = curl_easy_init();

	if(NULL == p_curl_handle)
	{
		printf("\n s_get_download_file_length  if(NULL == p_curl_handle) \n");
		return -1;
	}
	/*
	* You better replace the URL with one that works! Note that we use an
	* FTP:// URL with standard explicit FTPS. You can also do FTPS:// URLs if
	* you want to do the rarer kind of transfers: implicit.
	*/
	curl_easy_setopt(p_curl_handle, CURLOPT_URL,pstuFtpConnectParam->chUrl);
	curl_easy_setopt(p_curl_handle, CURLOPT_USERPWD, pstuFtpConnectParam->chUserPwd);
	/* Define our callback to get called when there's data to be written */
	curl_easy_setopt(p_curl_handle, CURLOPT_WRITEFUNCTION, my_fwrite);
	/* Set a pointer to our struct to pass to the callback */
	curl_easy_setopt(p_curl_handle, CURLOPT_WRITEDATA, pstuFtpFile);

	//time out
	//curl_easy_setopt(curlhandle, CURLOPT_CONNECTTIMEOUT, timeout);

	curl_easy_setopt(p_curl_handle, CURLOPT_PROGRESSFUNCTION,my_progress_callback );
	curl_easy_setopt(p_curl_handle, CURLOPT_PROGRESSDATA,NULL);
	curl_easy_setopt(p_curl_handle, CURLOPT_NOPROGRESS, 0L);

	/* We activate SSL and we require it for both control and data */
	curl_easy_setopt(p_curl_handle, CURLOPT_USE_SSL, CURLUSESSL_ALL);

	/* Switch on full protocol/debug output */
	curl_easy_setopt(p_curl_handle, CURLOPT_VERBOSE, 1L);

	res = curl_easy_perform(p_curl_handle);

	/* always cleanup */
	curl_easy_cleanup(p_curl_handle);

	if(CURLE_OK == res)
	{
	    /* we success */
	    fprintf(stdout, "curl told us %d! finish!!!!!\n", res);
	}
	else
	{
	    /* we failed */
	    fprintf(stderr, "curl told us %d\n", res);
	}
	
	return 0;
}

int ftp_init(void *param)
{
	s_curl_init();
	return 0;
}

int s_curl_init()
{
	curl_global_init(CURL_GLOBAL_DEFAULT);
	return 0;
}

int s_curl_term()
{
	curl_global_cleanup();
	return 0;
}

static size_t save_header(void *ptr, size_t size, size_t nmemb, void *data)
{
    return (size_t)(size * nmemb);
}

double s_get_download_file_length(ftp_connect_param_t * pstuFtpConnectParam)
{
	double len= 0.0;
	CURL *p_curl_handle = NULL;
	CURLcode res;

	if((NULL == pstuFtpConnectParam)
		|| (0 == strlen(pstuFtpConnectParam->chUrl))
		|| (0 == strlen(pstuFtpConnectParam->chUserPwd)))
	{
		printf("\n s_get_download_file_length  param error \n");
		return -1;
	}

	p_curl_handle = curl_easy_init();

	if(NULL == p_curl_handle)
	{
		printf("\n s_get_download_file_length  if(NULL == p_curl_handle) \n");
		return -1;
	}
	
	curl_easy_setopt(p_curl_handle, CURLOPT_URL, pstuFtpConnectParam->chUrl);
	curl_easy_setopt(p_curl_handle, CURLOPT_HEADER, 1);	 //只要求header头
	curl_easy_setopt(p_curl_handle, CURLOPT_NOBODY, 1);	 //不需求body
	curl_easy_setopt(p_curl_handle, CURLOPT_HEADERFUNCTION, save_header);
	curl_easy_setopt(p_curl_handle, CURLOPT_USERPWD, pstuFtpConnectParam->chUserPwd);

	res = curl_easy_perform(p_curl_handle);
	if (res == CURLE_OK)
	{
		res= curl_easy_getinfo(p_curl_handle, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &len);
        if(CURLE_OK == res)
		{
			printf("  curl_easy_getinfo CURLE_OK !\n");
		}
		else
		{
            printf("curl_easy_getinfo failed!  res = %d\n",res);
		}
	}
	else
	{
		printf("\n s_get_download_file_length====== res = %d   \n",res);
	    len= -1;
	}

	curl_easy_cleanup(p_curl_handle);
	return len ;
}

void set_ftp_file(ftp_file_t *pstuFtpFile, char *pchFileName)
{
	if(NULL == pstuFtpFile)
	{
		printf("\n if(NULL != pstuFtpFile)  set_ftp_file \n ");
		return;
	}
	pstuFtpFile->nFileLength = 0.0;
	pstuFtpFile->pchFilename = pchFileName;
	pstuFtpFile->stream = NULL;
	pstuFtpFile->nPersent = 0;
	pstuFtpFile->nCount =0.0;
}

void set_ftp_connect_param(ftp_connect_param_t * pstuFtpConnectParam)
{
	if(NULL == pstuFtpConnectParam)
	{
		printf("\n if(NULL == pstuFtpConnectParam)  set_ftp_connect_param \n ");
		return;
	}

	memset(pstuFtpConnectParam,0,sizeof(ftp_connect_param_t));
	strncpy(pstuFtpConnectParam->chUserName,"anonymous",sizeof(pstuFtpConnectParam->chUserName)-1);

	strncpy(pstuFtpConnectParam->chPassword," ",sizeof(pstuFtpConnectParam->chPassword)-1); 
    snprintf(pstuFtpConnectParam->chUserPwd,sizeof(pstuFtpConnectParam->chUserPwd),
		"%s:%s",
		pstuFtpConnectParam->chUserName,
		pstuFtpConnectParam->chPassword);
	strncpy(pstuFtpConnectParam->chUrl,FtpUrl,sizeof(pstuFtpConnectParam->chPassword)-1);
}