declaration in my class.
static size_t read_callback(void * pBuffer, size_t size, size_t nmemb, void * hFile); 
Note: this callback is itself Static and it is Static member function of my class.


CURLcode CProxyCurl::UploadFile( char * URL , char *Filepath, char *filename )
{
	

	gCallbackcount = 0;
	CURLcode result = CURLE_OK;
	long HttpResponse;
	long HttpConnectResponse;
	long TotalUploadSize;
	_TCHAR Url[512]={0};
	if (m_pcurl)
    {
		struct curl_httppost* post = NULL;
		struct curl_httppost* last = NULL;
		struct curl_slist *headerlist=NULL;
		static const char buf[] = "Expect:";
		static const char buf1[] = "Transfer-Encoding: chunked";
		static char buf2[256] = {0};
		
		
		HANDLE fp			= NULL ;
		if( (fp = fopen( Filepath ,"rb")) !=  NULL )
		{
			EC_LOG( TestMessageFile, (LPTSTR)(_T(Filepath)), result) ;
			_finddata_t c_file ;
		    long hFind;

		   	if( (hFind = _findfirst( Filepath, &c_file )) != -1L )
			{
				_findclose( hFind ) ;
			} 

			_snprintf( Url,sizeof(Url)-1, "%s&file_size=%lu", URL, c_file.size ) ;

			curl_easy_setopt(m_pcurl, CURLOPT_URL, Url);
			EC_LOG( TestMessageFile, (LPTSTR)(_T(Url)), result) ;
			curl_easy_setopt(m_pcurl, CURLOPT_PORT, ENS_COMM_PORT);	
			curl_easy_setopt(m_pcurl,CURLOPT_SSL_VERIFYPEER, 0 );
			curl_easy_setopt(m_pcurl, CURLOPT_SSL_VERIFYHOST, 0);
		
			
			if( m_IsProxyEnabled != 0 )
			{
				SetOptionForProxy();
			}

			headerlist = curl_slist_append(headerlist, buf);
			headerlist = curl_slist_append(headerlist, buf1);
			_snprintf( (char*)buf2,sizeof( buf2) -1 ,"olqfilesize: %lu", c_file.size );
			headerlist = curl_slist_append(headerlist, buf2);
			curl_easy_setopt(m_pcurl, CURLOPT_HTTPHEADER, headerlist);

			CURLFORMcode result3;
			result3 = curl_formadd(&post, &last, CURLFORM_COPYNAME, "uploadedfile",
					CURLFORM_STREAM, fp,
					CURLFORM_CONTENTSLENGTH, c_file.size,
					CURLFORM_FILENAME, filename, 
					//CURLFORM_CONTENTTYPE, "application/octet-stream",
					CURLFORM_END);
	
			curl_easy_setopt(m_pcurl, CURLOPT_READFUNCTION, read_callback);

			curl_easy_setopt(m_pcurl, CURLOPT_HTTPPOST, post);
			
			
			EC_LOG( TestMessageFile, (LPTSTR)(_T("c_file.size:")), c_file.size) ;
			EC_LOG( TestMessageFile, (LPTSTR)(_T("before easy perform")), result) ;
			result = curl_easy_perform(m_pcurl);  

			EC_LOG( TestMessageFile, (LPTSTR)(_T("Upload Result:")), result) ;
			result = curl_easy_getinfo(m_pcurl, CURLINFO_HTTP_CONNECTCODE  , &HttpConnectResponse);	
			result = curl_easy_getinfo(m_pcurl, CURLINFO_RESPONSE_CODE , &HttpResponse);						
			result = curl_easy_getinfo(m_pcurl, CURLINFO_SIZE_UPLOAD  , &TotalUploadSize);						

			EC_LOG( TestMessageFile, (LPTSTR)(_T("HttpConnectResponse:")), HttpConnectResponse) ;
			EC_LOG( TestMessageFile, (LPTSTR)(_T("HttpResponse:")), HttpResponse) ;
			EC_LOG( TestMessageFile, (LPTSTR)(_T("TotalUploadSize:")), TotalUploadSize) ;
			
			curl_slist_free_all (headerlist);
			curl_formfree(post); 
			fclose((FILE*)fp);
			
		}
		else
		{
//			result = STATUS_ERROR;
			EC_LOG( TestMessageFile, (LPTSTR)(_T("fail to open file")), result) ;
			EC_LOG( TestMessageFile, (LPTSTR)(_T(Filepath)), result) ;
		}
		
	 }

	return result;
}


size_t CProxyCurl::read_callback(void * pBuffer, size_t size, size_t nmemb, void * hFile) 
{ 
	EC_SETFUNCNAME( _T("CProxyCurl::read_callback()") ) ;
	
	int NoOfBytesRead = 0;
	gCallbackcount = gCallbackcount+ 1;
	if( gbterminateTransfer != TRUE )
	{	
		
	//	if( ( NoOfBytesRead = fread( pBuffer, sizeof( char ),RECV_BUFF_SIZE, (FILE*)hFile ) ) == RECV_BUFF_SIZE  )
		if( ( NoOfBytesRead = fread( pBuffer, size, nmemb, (FILE*)hFile ) ) == nmemb  )
		{

		
			//printf("NoOfBytesRead:%d",NoOfBytesRead);
		}
		else
		{
			//printf(" else : NoOfBytesRead:%d\n",NoOfBytesRead);
			int error = 0 ;

			error = ferror( (FILE*)hFile ) ;

			if( error )
			{
			//	printf( "error reading file" ) ;

		//		return Error ;
			}

			error = feof((FILE*) hFile ) ;

		
			
		}
	}
	else
	{
	//	EC_LOG( TestMessageFile, (LPTSTR)(_T("CURLE_ABORTED_BY_CALLBACK: NoOfBytesRead:")), ( GetFileInfo())->m_bterminateTransfer) ;
		EC_LOG( TestMessageFile, (LPTSTR)(_T("CURLE_ABORTED_BY_CALLBACK: NoOfBytesRead:")), NoOfBytesRead) ;
		gbterminateTransfer = FALSE ;
		return -1 ;
		
	}
	EC_LOG( TestMessageFile, (LPTSTR)(_T("NoOfBytesRead:")), NoOfBytesRead) ;
	EC_LOG( TestMessageFile, (LPTSTR)(_T("size:")), gCallbackcount) ;
//	EC_LOG( TestMessageFile, (LPTSTR)(_T("nmemb:")), nmemb) ;
	return NoOfBytesRead;
}