int SVUnixOpMonitor::telnetinit()
{
unsigned long ip;
hostent *ent;
sockaddr_in sa;
// SOCKET hSocket;
ent = gethostbyname(strRemoteHost);
if(ent == NULL)
return HOSTERROR;
ip = *(unsigned long*)(ent->h_addr);
sa.sin_family = AF_INET;
sa.sin_port = htons(nPort);
sa.sin_addr = *(in_addr*)&ip;
hSocket = socket(PF_INET,SOCK_STREAM,IPPROTO_TCP);
if (hSocket == INVALID_SOCKET)
return SOCKETINITERROR;
if(connect_timeo(hSocket, (sockaddr*)&sa, sizeof(sockaddr), CONNECT_TIMEOUT) < 0)
return CONNECTTIMEOUTERROR;
return TELNETSUCCESS;
}
/*
Usage: forward the name request to the responsible server, and send the reply
from that server directly back to the requester
Return: -1 on error, 1 if OK
*/
int forward_request(int sockfd, int logfd, char *data, char *ipaddr, int port,
ssize_t n)
{
int sfd, m;
int flag = -1;
char recvline[MAXBYTE];
struct sockaddr_in servaddr;
write_log(logfd, "[Info] forward_request -- forward the request");
// initialize a new socket
sfd = socket(AF_INET, SOCK_STREAM, 0);
if (sfd == -1) {
fprintf(stderr, "[Error] forward_request -- fail to initial socket\n");
write_log(logfd, "[Error] forward_request -- fail to initial socket");
return flag;
}
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr(ipaddr);
servaddr.sin_port = htons(port);
// tcp connect with timeout
if (connect_timeo(sfd, (struct sockaddr *) &servaddr,
sizeof(servaddr), CONNECT_TIMEO) < 0) {
fprintf(stderr, "[Error] forward_request -- connect failed\n");
write_log(logfd, "[Error] forward_request -- connect failed");
return flag;
}
// forward the request to another server
m = write(sfd, data, n);
if (m == EOF && m == -1) {
fprintf(stderr, "[Error] forward_request -- forward failed\n");
write_log(logfd, "[Error] forward_request -- forward failed");
return flag;
}
if ((m = read_timeo(sfd, recvline, MAXBYTE, TRANS_TIMEO)) > 0) {
write(sockfd, recvline, m);
}
close(sfd);
flag = 1;
return flag;
}
BOOL PORT_MONITOR(char *server, int port, char *sendstring, char *matchstring,
int timeout, char *pserver, int pport, char *puid, char *ppwd,
char *custpath, char *szReturn)
{
DWORD dwBeginTime = 0,
dwEndTime = 0;
int n = 0, ret = 0;
SOCKET s = 0;
dwBeginTime = GetTickCount();
// Create Socket
s = socket(AF_INET,SOCK_STREAM,0);
if (s == INVALID_SOCKET)
{
// Create Socket Error
sprintf(szReturn, "error=%s", ::FuncGetStringFromIDS("<%IDS_Port_1%>"));//<%IDS_Port_1%>
return FALSE;
}
if(*pserver)
{
if(socks5_protocol(s, server, port, pserver, pport, puid, ppwd, timeout))
{
// Sock5 Proxy Error
sprintf(szReturn, "error=%s", ::FuncGetStringFromIDS("<%IDS_Port_2%>"));//<%IDS_Port_2%>
return FALSE;
}
}
else
{
struct sockaddr_in serv;
struct hostent *hp;
hp = gethostbyname(server);
if(hp == NULL)
{
// DNS Resolve Error
sprintf(szReturn, "error=%s", ::FuncGetStringFromIDS("<%IDS_Port_3%>"));//<%IDS_Port_3%>
return FALSE;
}
// Connect to the host specialed nonblocking
memcpy(&serv.sin_addr, hp->h_addr_list[0], hp->h_length);
serv.sin_family = hp->h_addrtype;
serv.sin_port=htons(port);
if (connect_timeo(s, (struct sockaddr *)&serv, sizeof(serv), timeout))
{
shutdown(s, 0x02);
closesocket(s);
// Server Port Connect Error
sprintf(szReturn, "error=%s", ::FuncGetStringFromIDS("<%IDS_Port_4%>"));//<%IDS_Port_4%>
return FALSE;
}
}
if(*sendstring)
{
CString strSend = sendstring;
strSend.Replace("\\r", "\r");
strSend.Replace("\\n", "\n");
n = send(s, strSend, strSend.GetLength(), 0);
if(n == SOCKET_ERROR)
{
// Send Data Error
sprintf(szReturn, "error=%s", ::FuncGetStringFromIDS("<%IDS_Port_5%>"));//<%IDS_Port_5%>
shutdown(s, 0x02);
closesocket(s);
return FALSE;
}
}
if(*matchstring)
{
char reply[8192] = {0};
ret = RESPONSE_WAIT(s, timeout);
if(ret > 0)
{
memset(reply, 0, 8192);
n = recv(s, reply, 8192, 0);
if(n <= 0)
{
shutdown(s, 0x02);
closesocket(s);
// Content Match Error
sprintf(szReturn, "error=%s", ::FuncGetStringFromIDS("<%IDS_Port_6%>"));//<%IDS_Port_6%>
return FALSE;
}
if(!strstr(reply, matchstring))
{
shutdown(s, 0x02);
closesocket(s);
// Content Match Error
sprintf(szReturn, "error=%s", ::FuncGetStringFromIDS("<%IDS_Port_7%>"));//<%IDS_Port_7%>
return FALSE;
}
}
else if(ret == 0)
{
shutdown(s, 0x02);
closesocket(s);
// Read Data Timeout
sprintf(szReturn, "error=%s", ::FuncGetStringFromIDS("<%IDS_Port_8%>"));//<%IDS_Port_8%>
return FALSE;
}
else
{
shutdown(s, 0x02);
closesocket(s);
// Read Data Error
sprintf(szReturn, "error=%s", ::FuncGetStringFromIDS("<%IDS_Port_9%>"));//<%IDS_Port_9%>
return FALSE;
}
}
shutdown(s, 0x02);
closesocket(s);
dwEndTime = GetTickCount();
sprintf(szReturn, "TotalTime=%ld$", dwEndTime - dwBeginTime);
return TRUE;
}
int TcpConnectPort(char *Host, int Port, char *SendStr, char *MatchStr, int Timeout, char *szReturn)
{
struct sockaddr_in serv;
LPHOSTENT lpHost;
int tcpSocket, n = 0, ret = 0;
char request[100] = {0};
char reply[100] = {0};
if(*SendStr)
{
if(strlen(SendStr) <= 100)
strcpy(request, SendStr);
else
strncpy(request, SendStr, 100);
}
lpHost = gethostbyname(Host);
if(lpHost == NULL)
{
// DNS Resolve Error
sprintf(szReturn, "error=%s", ::FuncGetStringFromIDS("<%IDS_Port_10%>"));//<%IDS_Port_10%>
return -1;
}
// Create Socket
tcpSocket = socket(AF_INET,SOCK_STREAM,0);
if (tcpSocket < 0)
{
// Create Socket Error
sprintf(szReturn, "error=%s", ::FuncGetStringFromIDS("<%IDS_Port_11%>"));//<%IDS_Port_11%>
return -1;
}
// Connect to the host specialed nonblocking
memcpy(&serv.sin_addr,lpHost->h_addr_list[0],lpHost->h_length);
serv.sin_family = lpHost->h_addrtype;
serv.sin_port=htons(Port);
if (connect_timeo(tcpSocket, (struct sockaddr *)&serv, sizeof(serv), 10))
{
shutdown(tcpSocket, 0x02);
closesocket(tcpSocket);
// Server Port Connect Error
sprintf(szReturn, "error=%s", ::FuncGetStringFromIDS("<%IDS_Port_12%>"));//<%IDS_Port_12%>
return -1;
}
if(*request)
{
n = send(tcpSocket, request, strlen(request), 0);
if(n == SOCKET_ERROR)
{
// Send Data Error
sprintf(szReturn, "error=%s", ::FuncGetStringFromIDS("<%IDS_Port_13%>"));//<%IDS_Port_13%>
shutdown(tcpSocket, 0x02);
closesocket(tcpSocket);
return -1;
}
}
if(*MatchStr)
{
ret = RESPONSE_WAIT(tcpSocket, Timeout);
if(ret > 0)
{
n = recv(tcpSocket, reply, 100, 0);
if(n == SOCKET_ERROR)
{
shutdown(tcpSocket, 0x02);
closesocket(tcpSocket);
// Read Data Error
sprintf(szReturn, "error=%s", ::FuncGetStringFromIDS("<%IDS_Port_14%>"));//<%IDS_Port_14%>
return -1;
}
if(n == 0)
{
shutdown(tcpSocket, 0x02);
closesocket(tcpSocket);
// Content Match Error
sprintf(szReturn, "error=%s", ::FuncGetStringFromIDS("<%IDS_Port_15%>"));//<%IDS_Port_15%>
return -1;
}
if(!strstr(reply, MatchStr))
{
shutdown(tcpSocket, 0x02);
closesocket(tcpSocket);
// Content Match Error
sprintf(szReturn, "error=%s", ::FuncGetStringFromIDS("<%IDS_Port_16%>"));//<%IDS_Port_16%>
return -1;
}
}
else
{
shutdown(tcpSocket, 0x02);
closesocket(tcpSocket);
// Read Data Error
sprintf(szReturn, "error=%s", ::FuncGetStringFromIDS("<%IDS_Port_17%>"));//<%IDS_Port_17%>
return -1;
}
}
shutdown(tcpSocket, 0x02);
closesocket(tcpSocket);
return 0;
}
BOOL CSMTP::Connect(int nNeedAuth, CString vUid, CString vPwd)
{
CString sHello;
TCHAR local_host[ 80 ]; // Warning: arbitrary size
if( m_bConnected )
return TRUE;
try
{
// This will be deleted in Disconnect();
response_buf = new TCHAR[ RESPONSE_BUFFER_SIZE ];
// I can't count on all class users' applications
// to have exception-throwing operator-new implementations,
// so I'll soul-kiss the ones that don't.
if( response_buf == NULL )
{
//m_sError = _T( "内存溢出" );//<%IDS_SMTP_2%>
m_sError = ::FuncGetStringFromIDS("<%IDS_SMTP_2%>");
return FALSE;
}
}
catch( CException *e )
{
response_buf = NULL;
//m_sError = _T( "内存溢出" );//<%IDS_SMTP_3%>
m_sError = ::FuncGetStringFromIDS("<%IDS_SMTP_3%>");
delete e;
return FALSE;
}
m_wsSMTPServer = socket(AF_INET, SOCK_STREAM, 0);
if(m_wsSMTPServer == INVALID_SOCKET)
{
//m_sError = _T( "通信建立失败" );//<%IDS_SMTP_4%>
m_sError = ::FuncGetStringFromIDS("<%IDS_SMTP_4%>");
delete response_buf;
response_buf = NULL;
return FALSE;
}
struct hostent *hp;
struct sockaddr_in serv;
hp = gethostbyname(GetServerHostName());
if(hp == NULL)
{
//m_sError = _T( "域名解析失败" );//<%IDS_SMTP_5%>
m_sError = ::FuncGetStringFromIDS("<%IDS_SMTP_5%>");
shutdown(m_wsSMTPServer, 0x02);
closesocket(m_wsSMTPServer);
delete response_buf;
response_buf = NULL;
return FALSE;
}
int i = 0;
while(1)
{
if(hp->h_addr_list[i])
memcpy(&serv.sin_addr,hp->h_addr_list[i],hp->h_length);
else
{
//m_sError = _T( "主机连接失败" );//<%IDS_SMTP_6%>
m_sError = ::FuncGetStringFromIDS("<%IDS_SMTP_6%>");
shutdown(m_wsSMTPServer, 0x02);
closesocket(m_wsSMTPServer);
delete response_buf;
response_buf = NULL;
return FALSE;
}
serv.sin_family = AF_INET;
serv.sin_port=htons(GetPort());
// if (connect(m_wsSMTPServer, (struct sockaddr*)&serv, sizeof(serv)) != SOCKET_ERROR)
if (connect_timeo(m_wsSMTPServer, (struct sockaddr*)&serv, sizeof(serv), CONNECT_TIMEOUT) == 0)
{
break;
}
i ++;
}
if( !get_response( CONNECT_SUCCESS ) )
{
//m_sError = _T( "主机无响应" );//<%IDS_SMTP_7%>
m_sError = ::FuncGetStringFromIDS("<%IDS_SMTP_7%>");
shutdown(m_wsSMTPServer, 0x02);
closesocket(m_wsSMTPServer);
delete response_buf;
response_buf = NULL;
return FALSE;
}
gethostname( local_host, 80 );
if(nNeedAuth)
sHello.Format( _T( "EHLO %s\r\n" ), local_host );
else
sHello.Format( _T( "HELO %s\r\n" ), local_host );
send(m_wsSMTPServer, (LPCTSTR)sHello, sHello.GetLength(), 0);
if( !get_response( GENERIC_SUCCESS ) )
{
//m_sError = _T("发送HELO命令失败");//<%IDS_SMTP_8%>
m_sError = ::FuncGetStringFromIDS("<%IDS_SMTP_8%>");
shutdown(m_wsSMTPServer, 0x02);
closesocket(m_wsSMTPServer);
delete response_buf;
response_buf = NULL;
return FALSE;
}
//get_response( GENERIC_SUCCESS ) ;
/*
if( !get_response( GENERIC_SUCCESS ) )
{
//m_sError = _T("发送HELO命令失败");//<%IDS_SMTP_8%>
m_sError = ::FuncGetStringFromIDS("<%IDS_SMTP_8%>");
shutdown(m_wsSMTPServer, 0x02);
closesocket(m_wsSMTPServer);
delete response_buf;
response_buf = NULL;
return FALSE;
}
*/
if(nNeedAuth)
{
CString sAuth = _T("");
CBase64 *pBase64 = new CBase64();
sAuth = _T("AUTH LOGIN\r\n");
send(m_wsSMTPServer, (LPCTSTR)sAuth, sAuth.GetLength(), 0);
if( !get_response( AUTH_RESPONSE ) )
{
//m_sError = _T("身份验证失败");//<%IDS_SMTP_9%>
m_sError = ::FuncGetStringFromIDS("<%IDS_SMTP_9%>");
shutdown(m_wsSMTPServer, 0x02);
closesocket(m_wsSMTPServer);
delete pBase64;
pBase64 = NULL;
delete response_buf;
response_buf = NULL;
return FALSE;
}
//get_response( AUTH_RESPONSE );
sAuth.Format(_T("%s\r\n"), pBase64->Encode((LPCTSTR)vUid, vUid.GetLength()));
send(m_wsSMTPServer, (LPCTSTR)sAuth, sAuth.GetLength(), 0);
if( !get_response( AUTH_RESPONSE ) )
{
//m_sError = _T("发送身份验证用户名失败");//<%IDS_SMTP_10%>
m_sError = ::FuncGetStringFromIDS("<%IDS_SMTP_10%>");
shutdown(m_wsSMTPServer, 0x02);
closesocket(m_wsSMTPServer);
delete pBase64;
pBase64 = NULL;
delete response_buf;
response_buf = NULL;
return FALSE;
}
sAuth.Format(_T("%s\r\n"), pBase64->Encode((LPCTSTR)vPwd, vPwd.GetLength()));
send(m_wsSMTPServer, (LPCTSTR)sAuth, sAuth.GetLength(), 0);
if( !get_response( AUTH_SUCCESS ) )
{
//m_sError = _T("发送身份验证密码失败");//<%IDS_SMTP_11%>
m_sError = ::FuncGetStringFromIDS("<%IDS_SMTP_11%>");
shutdown(m_wsSMTPServer, 0x02);
closesocket(m_wsSMTPServer);
delete pBase64;
pBase64 = NULL;
delete response_buf;
response_buf = NULL;
return FALSE;
}
delete pBase64;
pBase64 = NULL;
}
m_bConnected = TRUE;
return TRUE;
}
void
Connect_timeo(int fd, const SA *sa, socklen_t salen, int sec)
{
if (connect_timeo(fd, sa, salen, sec) < 0)
err_sys("connect_timeo error");
}
int OpenControlChannel(char *hostname, int port, char *username, char *password, int timeout, char *retrfile,
int ptype, char *pserver, int pport, char *puid, char *ppwd, char *szReturn, CFtpParam& ftpParam)
{
struct sockaddr_in sa;
struct hostent *hp;
char buffer[1024] = {0};
int ret = 0;
CString strCmd = _T("");
CString strMessage = _T("");
if(*pserver)
{
// Use Proxy
switch(ptype)
{
case 0:
// Common Proxy
hp = gethostbyname(pserver);
if(!hp)
{
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_PROXY",
"PROXY_DOMAIN_NAME_PARSER_ERROR"));//<%IDS_FTP_1%>
return 1;
}
memcpy(&sa.sin_addr,hp->h_addr_list[0],hp->h_length);
sa.sin_family = AF_INET;
sa.sin_port=htons(pport);
if (connect_timeo(ftpParam.ctrlSocket, (struct sockaddr *)&sa, sizeof(sa), timeout))
{
shutdown(ftpParam.ctrlSocket, 0x02);
closesocket(ftpParam.ctrlSocket);
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_PROXY",
"PROXY_CONNECT_FAILED"));//<%IDS_FTP_2%>
return 1;
}
break;
case 1:
// Socks5 Proxy
if(socks5_protocol(ftpParam.ctrlSocket, hostname, port, pserver, pport, puid, ppwd, timeout))
{
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_PROXY",
"PROXY_SERVER_ERROR"));//<%IDS_FTP_3%>
return 1;
}
break;
default:
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_FTP",
"FTP_UNKNOWN_PROXY_TYPE"));//<%IDS_FTP_4%>
return 1;
}
}
else
{
// Direct Connect
hp = gethostbyname(hostname);
if(!hp)
{
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_DNS",
"DNS_DOMAIN_NAME_PARSE_ERROR"));//<%IDS_FTP_5%>
return 1;
}
memcpy(&sa.sin_addr,hp->h_addr_list[0],hp->h_length);
sa.sin_family = AF_INET;
sa.sin_port=htons(port);
if (connect_timeo(ftpParam.ctrlSocket, (struct sockaddr *)&sa, sizeof(sa), timeout))
{
shutdown(ftpParam.ctrlSocket, 0x02);
closesocket(ftpParam.ctrlSocket);
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_FTP",
"FTP_CONNET_FAILED"));//<%IDS_FTP_6%>
return 1;
}
}
CString retMsg = _T("");
if(WaitVersionInfo(ftpParam.ctrlSocket, timeout))
{
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_FTP",
"FTP_WAIT_INIT_INFO_TIMEOUT"));//<%IDS_FTP_7%>
return 1;
}
// Send USER Command
if(*pserver && ptype == 0)
strCmd.Format("USER %s@%s\r\n", username, hostname);
else
strCmd.Format("USER %s\r\n", username);
ret = FTP_COMMAND(ftpParam.ctrlSocket, strCmd, strMessage);
if(ret != 2 && ret != 3)
{
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_FTP",
"FTP_SEND_USERNAME_FAILED"));//<%IDS_FTP_8%>
return 1;
}
// Send PASS Command
strCmd.Format("PASS %s\r\n", password);
ret = FTP_COMMAND(ftpParam.ctrlSocket, strCmd, strMessage);
if(ret != 2 && ret != 3)
{
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_FTP",
"FTP_SEND_PWD_FAILED"));//<%IDS_FTP_9%>
return 1;
}
// Binary Mode
strCmd = "TYPE I\r\n";
ret = FTP_COMMAND(ftpParam.ctrlSocket, strCmd, strMessage);
if(ret != 2 && ret != 3)
{
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_FTP",
"FTP_APPLY_BINARY_MODE_ERROR"));//<%IDS_FTP_10%>
return 1;
}
if(ftpParam.passive_mode)
{
// Passive Mode
if(EnterPassiveMode(ftpParam))
{
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_FTP",
"FTP_APPLY_PASSIVITY_MODE_ERROR"));//<%IDS_FTP_11%>
return 1;
}
}
else
{
int Count = 0;
while(1)
{
ftpParam.local_port = rand() % 55536 + 10000;
sa.sin_family = AF_INET;
sa.sin_addr.s_addr = htonl(INADDR_ANY);
sa.sin_port=htons(ftpParam.local_port);
if(bind(ftpParam.dataSocket, (struct sockaddr *)&sa, sizeof(sa)) == SOCKET_ERROR)
{
if(Count < 5)
{
Count ++;
continue;
}
else
{
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_FTP",
"FTP_LOCATE_BIND_ERROR"));//<%IDS_FTP_12%>
return 1;
}
}
if(listen(ftpParam.dataSocket, 10) == SOCKET_ERROR)
{
if(Count < 5)
{
Count ++;
continue;
}
else
{
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_FTP",
"FTP_LOCATE_CREATE_COMMUNICATE_ERROR"));//<%IDS_FTP_13%>
return 1;
}
}
break;
}
struct sockaddr_in lsa;
int salen = sizeof(lsa);
if(getsockname(ftpParam.ctrlSocket, (struct sockaddr *)&lsa, &salen) == SOCKET_ERROR)
{
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_FTP",
"FTP_GET_LOCATE_INFO_ERROR"));//<%IDS_FTP_14%>
return 1;
}
strcpy(ftpParam.local_host, inet_ntoa(lsa.sin_addr));
strCmd.Format("PORT %s,%d,%d\r\n", ftpParam.local_host, ftpParam.local_port/256, ftpParam.local_port%256);
strCmd.Replace('.', ',');
ret = FTP_COMMAND(ftpParam.ctrlSocket, strCmd, strMessage);
if(ret < 0 || ret != 2)
{
if(!ftpParam.passive_mode)
{
//closesocket(dataSocket);
ftpParam.passive_mode = 1;
if(EnterPassiveMode(ftpParam))
{
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_FTP",
"FTP_APPLY_PASSIVITY_MODE_ERROR"));//<%IDS_FTP_15%>
return 1;
}
}
}
}
if(strlen(retrfile) > 0)
{
strCmd.Format("RETR %s\r\n", retrfile);
WriteString(ftpParam.ctrlSocket, strCmd);
ret = ReadString2(ftpParam.ctrlSocket,buffer);
if(ret != 1 && ret != 2 && ret != 3 && ret != 9)
{
if(ret == 5)
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_FTP",
"FTP_FILE_NOT_FOUND"));//<%IDS_FTP_16%>
else
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_FTP",
"FTP_UNKNOWN_ERROR"));//<%IDS_FTP_17%>
return 1;
}
}
return 0;
}
int OpenDataChannel(char *retrfile, int timeout, int ptype, char *pserver, int pport, char *puid, char *ppwd, char *szReturn, CFtpParam& ftpParam)
{
CString strCmd = _T("");
CString retMsg = _T("");
char buffer[1024] = {0};
SOCKET dataChannel;
if(ftpParam.passive_mode)
{
dataChannel = socket(AF_INET, SOCK_STREAM, 0);
if(dataChannel == SOCKET_ERROR)
{
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_FTP",
"FTP_CREATE_COMMUNICATE_ERROR"));//<%IDS_FTP_18%>
return 1;
}
if(*pserver && ptype == 1)
{
if(socks5_protocol(dataChannel, ftpParam.remote_host, ftpParam.remote_port,
pserver, pport, puid, ppwd, timeout))
{
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_FTP",
"FTP_CREATE_COMMUNICATE_ERROR"));//<%IDS_FTP_19%>
return 1;
}
}
else
{
struct sockaddr_in rsa;
rsa.sin_addr.s_addr = inet_addr(ftpParam.remote_host);
rsa.sin_family = AF_INET;
rsa.sin_port = htons(ftpParam.remote_port);
if(connect_timeo(dataChannel, (struct sockaddr *)&rsa, sizeof(rsa), timeout))
{
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_FTP",
"FTP_CREATE_COMMUNICATE_ERROR"));//<%IDS_FTP_20%>
return 1;
}
}
}
else
{
struct sockaddr_in rsa;
int rsalen = sizeof(rsa);
dataChannel = accept(ftpParam.dataSocket, (struct sockaddr *)&rsa, &rsalen);
if(dataChannel == INVALID_SOCKET)
{
sprintf(szReturn, "error=%s$", FuncGetStringFromIDS("SV_FTP",
"FTP_CREATE_COMMUNICATE_ERROR"));//<%IDS_FTP_21%>
return 1;
}
}
#ifdef SAVEASFILE
CFile datafile;
if(!datafile.Open("C:\\download\\download", CFile::modeWrite|CFile::modeCreate))
{
return 1;
}
#endif
DWORD recvBegin = GetTickCount();
while(1)
{
int iRead = 0;
char response[1025] = {0};
iRead = recv(dataChannel, response, 1024, 0);
if(!iRead || iRead == SOCKET_ERROR)
break;
else
{
#ifdef SAVEASFILE
datafile.Write(response, iRead);
#endif
ftpParam.recvBytes += iRead;
}
}
ftpParam.recvTickCount = GetTickCount() - recvBegin;
#ifdef SAVEASFILE
datafile.Close();
#endif
return 0;
}
