#include "ftp32api.h"
#include "config.h"
#include "ftp32.h"
#include "url.h"
#include "common.h"
#include "sock.h"
#include <string.h>
#include <stdio.h>
#include <sys/stat.h>
#include "ftpcmd.h"	/* for Ftp() API */

HINSTANCE _hInst;
static BOOL flagInProcess = FALSE;		/* use only PreAPI/PostAPI/GetRunning */
/* static BOOL flagBackGroundMode = FALSE;	
static BOOL flagCursorMode = FALSE;
*/
HWND OwnerWindow_hwnd=NULL;
HWND OwnerWindowEx_hwnd=NULL;
ARCHIVERPROC *OwnerWindowEx_proc=NULL;

static void PreAPI(void){flagInProcess=TRUE;}
static void PostAPI(void){flagInProcess=FALSE;}
static int GetRunning(void){return flagInProcess;}
static ftpconn *harc2ftpconn(HARC harc){
	return (ftpconn*)harc;
}
static struct ftpstat *harc2ftpstat(HARC harc){
	ftpconn *ftp = harc2ftpconn(harc);
	struct ftpstat *stat;
	
	if(ftp->statlist_current<0){return NULL;}
	stat = &ftp->statlist[ftp->statlist_current];
	return stat;
}
static WORD GetARCDate(time_t ti)
{
	struct tm tm,*tmptr;
	
	if(ti==0){
		memset(&tm,0,sizeof(struct tm));
		tm.tm_year = 1980 - 1900;
		tm.tm_mday = 1;
		tmptr = &tm;
	}else{
		tmptr=localtime(&ti);
	}
	return (((unsigned)tmptr->tm_year-(unsigned)80)<<9)+((tmptr->tm_mon+1)<<5)+(tmptr->tm_mday);
}
static WORD GetARCTime(time_t ti)
{
	struct tm *tmptr;
		
	if(ti==0){return 0;}
	tmptr = localtime(&ti);
	return ((tmptr->tm_hour)<<11)+((tmptr->tm_min)<<5)+((tmptr->tm_sec)/2);
}
static int get_ostypenum_from_osname(char *osname)
{
	if(strcmp(osname,"MS-DOS")==0){			/* from RFC1700 */
		return 0;
	}else if(strcmp(osname,"OS/2")==0){
		return 5;
	}else if(strcmp(osname,"UNIX")==0){
		return 2;
	}else{
		return 10;
	}
}
static int harc2individualinfo(HARC harc,INDIVIDUALINFO *info)
{
	int attr;

	info->dwOriginalSize = FtpGetOriginalSize(harc);
	info->dwCompressedSize = FtpGetCompressedSize(harc);
	info->dwCRC = FtpGetCRC(harc);

	info->uFlag = 0;	/* process result	*/
	info->uOSType = FtpGetOSType(harc);
	info->wRatio = FtpGetRatio(harc);
	info->wDate = FtpGetDate(harc);
	info->wTime = FtpGetTime(harc);
	FtpGetFileName(harc,info->szFileName,sizeof(info->szFileName));
	attr = FtpGetAttribute(harc);
	/* char	dummy1[3]; */
	info->szAttribute[0]= (attr & FA_ARCH) ? 'A' : '-'; /* Archive */
	info->szAttribute[1]= (attr & FA_SYSTEM) ?  'S' : '-'; /* System */
	info->szAttribute[2]= (attr & FA_HIDDEN) ? 'H' : '-'; /* Hide */
	info->szAttribute[3]= (attr & FA_RDONLY) ? 'R' : '-'; /* Read Only*/
	info->szAttribute[4]='\0';
	FtpGetMethod(harc,info->szMode,sizeof(info->szMode));		/*  mode */

	return 0;
}



WORD WINAPI FtpGetVersion(VOID)
{
#ifdef WIN32
	WORD ver;
	VS_FIXEDFILEINFO *verinfo;
	HRSRC res;
	HGLOBAL hres;
	
	res = FindResource(_hInst,MAKEINTRESOURCE(VS_VERSION_INFO),RT_VERSION);
	hres = LoadResource(_hInst,res);
	verinfo = (VS_FIXEDFILEINFO *)((char *)LockResource(hres) + 40);
	ver = (WORD)((verinfo->dwFileVersionMS >> 16) * 100 + (verinfo->dwFileVersionMS & 0xffff));
	return ver;
#else
	return FTP32_DLL_VERSION;
#endif
}

BOOL WINAPI _export FtpGetRunning(VOID)
{
	return GetRunning();
}
BOOL WINAPI _export FtpGetBackGroundMode(VOID)/* NO IMPLEMENT:return FALSE */
{
	return FALSE;
}
BOOL WINAPI _export FtpSetBackGroundMode(const BOOL _BackGroundMode)/* NO IMPLEMENT:return FALSE */
{
	return FALSE;
}
BOOL WINAPI _export FtpGetCursorMode(VOID)/* NO IMPLEMENT:return FALSE */
{
	return FALSE;
}
BOOL WINAPI _export FtpSetCursorMode(const BOOL _CursorMode)/* NO IMPLEMENT:return FALSE */
{
	return FALSE;
}
WORD WINAPI _export FtpGetCursorInterval(VOID)/* NO IMPLEMENT:return 80 */
{
	return 80;
}
BOOL WINAPI _export FtpSetCursorInterval(const WORD _Interval)/* NO IMPLEMENT:return FALSE */
{
	return FALSE;
}
BOOL WINAPI _export FtpCheckArchive(LPCSTR szFileName,const int iMode)
{
	int ret;
	char proto[1000],user[1000],pass[1000],host[1000],path[1000];int port;

	ret = parse_url(szFileName,proto,user,pass,host,&port,path);
	if(ret==-1){return FALSE;}
	if(strcmp(proto,"ftp")!=0){return FALSE;}
	return TRUE;
}
BOOL WINAPI _export FtpConfigDialog(const HWND hwnd,LPSTR szOption,const int iMode)
{
	int ret;

	load_setting();
	ret = DisplayConfigDialog(_hInst,hwnd);
	save_setting();
	return ret;
}
int WINAPI _export FtpGetFileCount(LPCSTR szArcFile)
{
	int ret;
	int count = 0;
	HARC harc;

	harc = FtpOpenArchive(NULL,szArcFile,0);
	ret = FtpFindFirst(harc,"",NULL);
	while(ret){
		count ++;
		ret = FtpFindNext(harc,NULL);
	}
	return count;
}
HARC WINAPI _export FtpOpenArchive(const HWND hWnd,LPCSTR szFileName,const DWORD dwMode)
{
	int ret;
	char proto[1000],user[1000],pass[1000],host[1000],path[1000];int port;
	ftpconn *ftp;
	
	if(!(dwMode & M_REGARDLESS_INIT_FILE)){
		load_setting();
	}
	
	ret = parse_url(szFileName,proto,user,pass,host,&port,path);
	if(ret==-1){return NULL;}
	if(strcmp(proto,"ftp")!=0){return NULL;}
	if(strcmp(user,"anonymous")==0 && *pass=='\0'){
		strcpy(pass,default_email);
	}
	if(port==21){port = default_ftpctrlport;}
	
	/* ftp = ftpopen(host,port,user,pass);*/
	ftp = ftpopen1();
	if(ftp==NULL){return NULL;}
	ftpsetproxy(ftp,default_proxytype,default_proxyhost,default_proxyport);
	ret = ftpopen2(ftp,host,port,user,pass);
	if(ret==-1){goto errorlabel;}
	ftpsetmode(ftp,default_passivemode);
	if(ftpchdir(ftp,path)==-1){goto errorlabel;}
	ftpsetresumegetmode(ftp,default_resumegetmode);

	return (HARC)ftp;
errorlabel:
	if(ftp){
		ftpclose(ftp);
	}
	return NULL;
}
int WINAPI _export FtpCloseArchive(HARC harc)
{
	ftpconn *ftp = (ftpconn*)harc;
	if(ftp){
		ftpclose(ftp);
	}
	return TRUE;
}
int WINAPI _export FtpFindFirst(HARC harc,LPCSTR szWildName,LPINDIVIDUALINFO lpSubInfo)
{
	char wildname[1000];
	char *ptr;
	int ret;
	ftpconn *ftp = harc2ftpconn(harc);
	

	strcpy(wildname,szWildName);
	(ptr = strrchr(wildname,'/')) || (ptr = strrchr(wildname,'\\'));
	if(!ptr){ptr=wildname;}else{ptr++;}
	if(strcmp("*.*",ptr)==0 || strcmp("*",ptr)==0){*ptr = '\0';}
	ret = ftpopendir(ftp,wildname);
	if(ret == -1){return -1;}
	return FtpFindNext(harc,lpSubInfo);
}

int WINAPI _export FtpFindNext(HARC harc,LPINDIVIDUALINFO lpSubInfo)
{
	ftpconn *ftp = harc2ftpconn(harc);
	struct ftpstat *stat;

	stat = ftpreaddir(ftp);
	if(stat==NULL){/* ftpclosedir(ftp); */return -1;}
	if(lpSubInfo!=NULL){
		harc2individualinfo(harc,lpSubInfo);
	}
	return 0;
}
int WINAPI _export FtpOpenFile(HARC harc,LPCSTR szFileName,LPCSTR rwmode,DWORD dwMode)
{
	int ret;
	ftpconn *ftp = harc2ftpconn(harc);

	ret = ftpopenfile(ftp,szFileName,rwmode);
	if(ret==-1){return -1;}
	return 0;
}
int WINAPI _export FtpRead(HARC harc,char *buff,int len)
{
	int ret;
	ftpconn *ftp = harc2ftpconn(harc);

	ret = ftpread(ftp,buff,len);
	return ret;
}
int WINAPI _export FtpWrite(HARC harc,const char *buff,int len)
{
	int ret;
	ftpconn *ftp = harc2ftpconn(harc);

	ret = ftpwrite(ftp,buff,len);
	return ret;
}
int WINAPI _export FtpCloseFile(HARC harc)
{
	int ret;
	ftpconn *ftp = harc2ftpconn(harc);

	ret = ftpclosefile(ftp);
	if(ret==-1){return -1;}
	return 0;
}
#if 0
static int ftpconn2exinfo(ftpconn *ftp,EXTRACTINGINFO *exinfo,int size)
{
	HARC harc = (HARC)ftp;

	exinfo->dwFileSize = FtpGetOriginalSize(harc);
	exinfo->dwWriteSize = size;
	FtpGetFileName(harc,exinfo->szSourceFileName,sizeof(info->szSourceFileName));
	/* exinfo->szDestFileName */
	return 0;
}
static int ftpconn2exinfoex(ftpconn *ftp,EXTRACTINGINFOEX *info,int size)
{
	int attr;

	ftpconn2exinfo(ftp,&(exinfoex->info));
	exinfoex->dwCompressedSize = FtpGetCompressedSize(harc);
	exinfoex->dwCRC = FtpGetCRC(harc);

	/* info->uFlag = 0;*/	/* process result	*/
	exinfoex->uOSType = FtpGetOSType(harc);
	exinfoex->wRatio = FtpGetRatio(harc);
	exinfoex->wDate = FtpGetDate(harc);
	exinfoex->wTime = FtpGetTime(harc);
	attr = FtpGetAttribute(harc);
	/* char	dummy1[3]; */
	exinfoex->szAttribute[0]= (attr & FA_ARCH) ? 'A' : '-'; /* Archive */
	exinfoex->szAttribute[1]= (attr & FA_SYSTEM) ?  'S' : '-'; /* System */
	exinfoex->szAttribute[2]= (attr & FA_HIDDEN) ? 'H' : '-'; /* Hide */
	exinfoex->szAttribute[3]= (attr & FA_RDONLY) ? 'R' : '-'; /* Read Only*/
	exinfoex->szAttribute[4]='\0';
	FtpGetMethod(harc,exinfo->szMode,sizeof(exinfo->szMode));		/*  mode */

	return 0;
}
static int (*callback)(ftpconn *ftp,int mode,int size,void *argp);
{
	int ret;

	EXTRACTINGINFOEX *exinfoex = (EXTRACTINGINFOEX *)argp;
	exinfoex->exinfo.dwWriteSize = size;
	ret = SendMessage(OwnerWindow_hwnd,WM_ARCEXTRACT_UIONT,ARCEXTRACT_INPROCESS);
	return ret;
}
#endif /* if 0 */
int WINAPI _export FtpExtract(HARC harc,LPCSTR remotefn,LPCSTR localfn,DWORD dwMode)
{
	int ret;
	ftpconn *ftp = harc2ftpconn(harc);
	/*EXTRACTINGINFOEX exinfoex;*/

	if(localfn==NULL || *localfn=='\0'){
		if(*default_basedir != '\0'){
			localfn = default_basedir;
		}
	}
	/*ftpsetcallback(ftp,callback,&exinfo);*/
	ret = ftpget(ftp,remotefn,localfn,"b");
	if(ret==-1){return FALSE;}
	return TRUE;
}
int WINAPI _export FtpAdd(HARC harc,LPCSTR remotefn,LPCSTR localfn,DWORD dwMode)
{
	int ret;
	ftpconn *ftp=harc2ftpconn(harc);

	ret = ftpput(ftp,remotefn,localfn,"b");
	if(ret==-1){return FALSE;}
	return TRUE;
}
int WINAPI _export FtpMove(HARC harc,LPCSTR from,LPCSTR to,DWORD dwMode)
{
	int ret;
	ftpconn *ftp=harc2ftpconn(harc);

	ret = ftprename(ftp,from,to);
	if(ret==-1){return FALSE;}
	return TRUE;	
}
int WINAPI _export FtpDelete(HARC harc,LPCSTR szFileName,DWORD dwMode)
{
	int ret;
	ftpconn *ftp=harc2ftpconn(harc);

	ret = ftpdelete(ftp,szFileName);
	if(ret==-1){return FALSE;}
	return TRUE;	
}
int WINAPI _export FtpMkDir(HARC harc,LPCSTR szFileName,DWORD dwMode)
{
	int ret;
	ftpconn *ftp=harc2ftpconn(harc);

	ret = ftpmkdir(ftp,szFileName);
	if(ret==-1){return FALSE;}
	return TRUE;	
}
int WINAPI _export FtpRmDir(HARC harc,LPCSTR szFileName,DWORD dwMode)
{
	int ret;
	ftpconn *ftp=harc2ftpconn(harc);

	ret = ftprmdir(ftp,szFileName);
	if(ret==-1){return FALSE;}
	return TRUE;	
}
int WINAPI _export FtpRestart(HARC harc,int pos)
{
	int ret;
	ftpconn *ftp=harc2ftpconn(harc);

	ret = ftprestart(ftp,pos);
	if(ret==-1){return FALSE;}
	return TRUE;	
}
int WINAPI _export FtpSetResumeGetMode(HARC harc,int onoff)
{
	int ret;
	ftpconn *ftp=harc2ftpconn(harc);

	ret = ftpsetresumegetmode(ftp,onoff);
	if(ret==-1){return FALSE;}
	return TRUE;	
}

int WINAPI _export FtpCancel(HARC harc,DWORD dwMode)
{
	int ret;
	ftpconn *ftp=harc2ftpconn(harc);

	ret = ftpcancel(ftp);
	if(ret==-1){return FALSE;}
	return TRUE;	
}

int WINAPI _export FtpSetCallbackMsgFunc(HARC harc,int (WINAPI *callbackmsgfunc)(char *msg,char *param),void *param)
{
	ftpconn *ftp = harc2ftpconn(harc);
	int ret;

	ret = ftpsetcallbackmsgfunc(ftp,callbackmsgfunc,param);
	if(ret==-1){return FALSE;}
	return TRUE;
}

int WINAPI _export FtpGetArcFileName(HARC harc, LPSTR _lpBuffer,
							const int _nSize)
{
	char url[1000];
	ftpconn *ftp=harc2ftpconn(harc);
	char host[1000];
	
	addr2hostname(&ftp->ctrlremoteaddr,host);
	build_url(url,"ftp",ftp->user,ftp->pass,host,ftp->ctrlremoteport,ftp->cd);
	strncpy2(_lpBuffer,url,_nSize);
	return 0;
}

DWORD WINAPI _export FtpGetArcFileSize(HARC harc)
{
	return FtpGetArcOriginalSize(harc);
}

DWORD WINAPI _export FtpGetArcOriginalSize(HARC harc)
{
	int size = 0;
	int i;
	ftpconn *ftp = harc2ftpconn(harc);

	for(i=0;i<ftp->statlistsize;i++){
		size += ftp->statlist[i].st_size;
	}
	return size;
}
DWORD WINAPI _export FtpGetArcCompressedSize(HARC harc)
{
	return FtpGetArcOriginalSize(harc);
}
WORD WINAPI _export FtpGetArcRatio(HARC _harc)
{
	return 1000;
}

WORD WINAPI _export FtpGetArcDate(HARC harc)
{
	time_t ti=0;
	int i;
	ftpconn *ftp = harc2ftpconn(harc);

	for(i=0;i<ftp->statlistsize;i++){
		if(strcmp(ftp->statlist[i].filename,".")==0){
			ti = ftp->statlist[i].st_mtime;
		}
	}
	return GetARCDate(ti);
}

WORD WINAPI _export FtpGetArcTime(HARC harc)
{
	time_t ti=0;
	int i;
	ftpconn *ftp = harc2ftpconn(harc);

	for(i=0;i<ftp->statlistsize;i++){
		if(strcmp(ftp->statlist[i].filename,".")==0){
			ti = ftp->statlist[i].st_mtime;
		}
	}
	return GetARCTime(ti);
}

UINT WINAPI _export FtpGetArcOSType(HARC harc)
{
	ftpconn *ftp = harc2ftpconn(harc);
	return get_ostypenum_from_osname(ftp->osname);
}
int WINAPI _export FtpGetFileName(HARC harc, LPSTR _lpBuffer,const int _nSize)
{
	struct ftpstat *stat = harc2ftpstat(harc);
	char *ptr;

	if(!stat){return -1;}
	strncpy2(_lpBuffer,stat->filename,_nSize-2);
	if(FtpGetAttribute(harc) & FA_DIREC){
		if(! ((ptr=strrchr(_lpBuffer,'/'))!=NULL && (_lpBuffer + strlen(_lpBuffer) -1) == ptr)){
			strcat(_lpBuffer,"/");
		}
	}
	return 0;
}
int WINAPI _export FtpGetMethod(HARC harc, LPSTR _lpBuffer,
							const int _nSize)
{
	struct ftpstat *stat = harc2ftpstat(harc);

	if(!stat){return -1;}
	strncpy2(_lpBuffer,"-ftp-",_nSize);
	return 0;
}
DWORD WINAPI _export FtpGetOriginalSize(HARC harc)
{
	struct ftpstat *stat = harc2ftpstat(harc);

	if(!stat){return -1;}
	return stat->st_size;
}
DWORD WINAPI _export FtpGetCompressedSize(HARC harc)
{
	return FtpGetOriginalSize(harc);
}
WORD WINAPI _export FtpGetRatio(HARC harc)
{
	return 1000;
}
WORD WINAPI _export FtpGetDate(HARC harc)
{
	struct ftpstat *stat = harc2ftpstat(harc);

	if(!stat){return -1;}
	return GetARCDate(stat->st_mtime);
}
WORD WINAPI _export FtpGetTime(HARC harc)
{
	struct ftpstat *stat = harc2ftpstat(harc);

	if(!stat){return -1;}
	return GetARCTime(stat->st_mtime);
}
DWORD WINAPI _export FtpGetWriteTime(HARC harc)
{
	struct ftpstat *stat = harc2ftpstat(harc);

	if(!stat){return -1;}
	return stat->st_mtime;
}
DWORD WINAPI _export FtpGetAccessTime(HARC harc)
{
	return FtpGetWriteTime(harc);
}
DWORD WINAPI _export FtpGetCreateTime(HARC harc)
{
	return FtpGetWriteTime(harc);
}
DWORD WINAPI _export FtpGetCRC(HARC _harc)
{
	return 0;
}
#if 0
#if defined(_S_IWRITE) && !defined(S_IWRITE)
#define S_IWRITE _S_IWRITE
#define S_IREAD _S_IREAD
#define S_IFDIR _S_IFDIR
#endif
#endif
int WINAPI _export FtpGetAttribute(HARC harc)
{
	struct ftpstat *stat = harc2ftpstat(harc);
	int st_mode;

	if(!stat){return -1;}
	st_mode = stat->st_mode;
	return 
		((st_mode & S_IWRITE)==0)*FA_RDONLY /* Read Only */
		+((st_mode & S_IREAD)==0)*FA_HIDDEN /* Hidden */
		+ 0 *FA_SYSTEM						/* System File */
		+ 0 *FA_LABEL						/* volume label */
		+((st_mode & S_IFDIR)!=0)*FA_DIREC /* Directory */
		+0*FA_ARCH;							/* Archive Attribute */
}

UINT WINAPI _export FtpGetOSType(HARC harc)
{
	return FtpGetArcOSType(harc);
}
int WINAPI _export FtpGetLinkName(HARC harc,LPSTR lpbuffer,const int nSize)
{
	struct ftpstat *stat = harc2ftpstat(harc);

	if(!stat){return -1;}
	strncpy(lpbuffer,stat->linkname,nSize);
	return 0;
}
int WINAPI _export FtpGetUserName(HARC harc,LPSTR lpbuffer,const int nSize)
{
	struct ftpstat *stat = harc2ftpstat(harc);

	if(!stat){return -1;}
	strncpy(lpbuffer,stat->username,nSize);
	return 0;
}
int WINAPI _export FtpGetGroupName(HARC harc,LPSTR lpbuffer,const int nSize)
{
	struct ftpstat *stat = harc2ftpstat(harc);

	if(!stat){return -1;}
	strncpy(lpbuffer,stat->groupname,nSize);
	return 0;
}
DWORD WINAPI _export FtpGetFileMode(HARC harc)
{
	struct ftpstat *stat = harc2ftpstat(harc);

	if(!stat){return -1;}
	return stat->st_mode;
}

BOOL WINAPI FtpSetDataConnectionMode(HARC harc,const int mode)
{
	ftpconn *ftp = harc2ftpconn(harc);

	if(!stat){return -1;}
	return ftpsetmode(ftp,mode);
}
int WINAPI _export FtpIsSFXFile(HARC harc)
{
	return FALSE;
}

BOOL WINAPI _export FtpSetOwnerWindow(const HWND hwnd)
{
	OwnerWindow_hwnd = hwnd;
	return FALSE;
}
BOOL WINAPI _export FtpClearOwnerWindow(void)
{
	OwnerWindow_hwnd = NULL;
	return FALSE;
}
BOOL WINAPI _export FtpSetOwnerWindowEx(HWND hwnd,ARCHIVERPROC *lpArcProc)
{
	OwnerWindowEx_hwnd = hwnd;
	OwnerWindowEx_proc = lpArcProc;
	return FALSE;
}
BOOL WINAPI _export FtpKillOwnerWindowEx(HWND hwnd)
{
	OwnerWindowEx_hwnd = NULL;
	OwnerWindowEx_proc = NULL;
	return FALSE;
}
BOOL WINAPI _export FtpQueryFunctionList(const int iFunction)
{
	int r;

	switch(iFunction){
	case ISARC						:r=TRUE;break;
	case ISARC_GET_VERSION			:r=TRUE;break;
	case ISARC_GET_CURSOR_INTERVAL	:r=FALSE;break;
	case ISARC_SET_CURSOR_INTERVAL	:r=FALSE;break;
	case ISARC_GET_BACK_GROUND_MODE	:r=FALSE;break;
	case ISARC_SET_BACK_GROUND_MODE	:r=FALSE;break;
	case ISARC_GET_CURSOR_MODE		:r=FALSE;break;
	case ISARC_SET_CURSOR_MODE		:r=FALSE;break;
	case ISARC_GET_RUNNING			:r=TRUE;break;

	case ISARC_CHECK_ARCHIVE		:r=TRUE;break;
	case ISARC_CONFIG_DIALOG		:r=TRUE;break;
	case ISARC_GET_FILE_COUNT		:r=TRUE;break;
	case ISARC_QUERY_FUNCTION_LIST	:r=TRUE;break;
	case ISARC_HOUT					:r=FALSE;break;					
	case ISARC_STRUCTOUT			:r=TRUE;break;
	case ISARC_GET_ARC_FILE_INFO	:r=TRUE;break;

	case ISARC_OPEN_ARCHIVE			:r=TRUE;break;
	case ISARC_CLOSE_ARCHIVE		:r=TRUE;break;
	case ISARC_FIND_FIRST			:r=TRUE;break;
	case ISARC_FIND_NEXT			:r=TRUE;break;
	case ISARC_EXTRACT				:r=TRUE;break;
	case ISARC_ADD					:r=TRUE;break;
	case ISARC_MOVE					:r=TRUE;break;
	case ISARC_DELETE				:r=TRUE;break;

	case ISARC_GET_ARC_FILE_NAME	:r=TRUE;break;
	case ISARC_GET_ARC_FILE_SIZE	:r=TRUE;break;
	case ISARC_GET_ARC_ORIGINAL_SIZE	:r=TRUE;break;
	case ISARC_GET_ARC_COMPRESSED_SIZE	:r=FALSE;break;
	case ISARC_GET_ARC_RATIO			:r=FALSE;break;
	case ISARC_GET_ARC_DATE				:r=TRUE;break;
	case ISARC_GET_ARC_TIME				:r=TRUE;break;
	case ISARC_GET_ARC_OS_TYPE			:r=TRUE;break;
	case ISARC_GET_ARC_IS_SFX_FILE		:r=FALSE;break;
	case ISARC_GET_FILE_NAME			:r=TRUE;break;
	case ISARC_GET_ORIGINAL_SIZE		:r=TRUE;break;
	case ISARC_GET_COMPRESSED_SIZE		:r=FALSE;break;
	case ISARC_GET_RATIO				:r=FALSE;break;
	case ISARC_GET_DATE					:r=TRUE;break;
	case ISARC_GET_TIME					:r=TRUE;break;
	case ISARC_GET_CRC					:r=TRUE;break;
	case ISARC_GET_ATTRIBUTE			:r=TRUE;break;
	case ISARC_GET_OS_TYPE				:r=TRUE;break;
	case ISARC_GET_METHOD				:r=TRUE;break;
	case ISARC_GET_WRITE_TIME			:r=TRUE;break;
	case ISARC_GET_CREATE_TIME			:r=TRUE;break;
	case ISARC_GET_ACCESS_TIME			:r=TRUE;break;

	default:
		r=FALSE;
		break;
	}
	return r;
}

BOOL WINAPI DllMain(HANDLE hInst,ULONG ul_reason_for_call,LPVOID lpReserved)
{
	_hInst = hInst;
	return TRUE;
}
int WINAPI _export Ftp(const HWND hWnd,LPCSTR szCmdLine,LPSTR szOutput,const DWORD wSize)
{
	return Ftp_Itr(hWnd,szCmdLine,szOutput,wSize);
}

#ifdef FTP32API_MAIN

int main(int argc,char *argv[])
{
	char output[30000];
	char cmdline[1000]="";
	int ret;
	int i;

	for(i=1;i<argc;i++){
		strcat(cmdline,argv[i]);
		strcat(cmdline," ");
	}
	ret = Ftp(NULL,cmdline,output,30000);
	puts(output);
	return 0;
}

#endif