1388 lines
31 KiB
C
1388 lines
31 KiB
C
#include "SHSSDK.h"
|
|
#include "main.h"
|
|
|
|
#undef HAVE_SSPI
|
|
|
|
#include "ne_request.h"
|
|
#include "ne_socket.h"
|
|
#include "ne_string.h"
|
|
#ifdef WIN32
|
|
#include "../Common/global_def.h"
|
|
|
|
#pragma comment(lib, "ws2_32.lib")
|
|
#endif
|
|
|
|
#ifndef WIN32
|
|
#define AUTHPRIME 137897
|
|
typedef struct _s_time_sync_t
|
|
{
|
|
int32_t sync_info;
|
|
}time_sync_t;
|
|
#endif
|
|
|
|
#pragma pack(1)
|
|
typedef struct {
|
|
char id[32];
|
|
char domain[128];
|
|
char domain2[128];
|
|
} SERVICE_STRUCT, *PSERVICE_STRUCT;
|
|
#pragma pack()
|
|
|
|
#pragma pack(1)
|
|
typedef struct {
|
|
char szTranId[52];
|
|
__int32 nMode;
|
|
char szIssuer[128];
|
|
char szServiceId[128];
|
|
__int32 nResult;
|
|
__int32 nLength;
|
|
} COMMAND_STRUCT, *PCOMMAND_STRUCT;
|
|
#pragma pack()
|
|
|
|
#define CENTER_HOST G_CENTERADDR
|
|
#define CENTER_PORT 80
|
|
|
|
#define RESOURCE_PORT 13104
|
|
#define GTLLOG_PORT 13103
|
|
//#define RESOURCE_PORT 80
|
|
|
|
#define PRIVATE_KEY "I'm your father"
|
|
#define SERVER_NAME "SHSSDK"
|
|
|
|
#define DELIMITER 0x1b
|
|
|
|
#define MSG_MODE_GET_FILE_NAME 0x010b
|
|
#define MSG_MODE_SSDK_GTS_GET_TRANSFER_LOG 0x0311
|
|
#define MSG_MODE_GTS_SSDK_SEND_TRANSFER_LOG 0x0312
|
|
#define MSG_MODE_SSDK_GTS_SEND_TRANSFER_LOG_RESP 0x0313
|
|
|
|
/* Elenoa MOD : START */
|
|
/* default timeout 5 second */
|
|
#include <fcntl.h>
|
|
|
|
static int timeout = 5;
|
|
static char szCacheFile[MAX_PATH]={0};
|
|
static int _sh_send(SOCKET s, char *buf, int len);
|
|
static int _sh_recv(SOCKET s, char *buf, int len);
|
|
const char *sh_get_rcts_host(const char *userId, const char *password, const char *serviceId);
|
|
char* get_address(const char *userId, const char *password, const char *serviceId,int nFlag);
|
|
int get_psl_from_cache(PSERVICE_STRUCT *psl);
|
|
int set_psl_to_cache(PSERVICE_STRUCT *psl,int nCount);
|
|
|
|
#ifdef _WIN32
|
|
static int __nonblock_win32(SOCKET s)
|
|
{
|
|
int ul = 1;
|
|
int result;
|
|
|
|
result = ioctlsocket( s, FIONBIO, (u_long FAR*)&ul );
|
|
|
|
return result;
|
|
}
|
|
#else
|
|
static int __nonblock(int fd)
|
|
{
|
|
int result;
|
|
int flags;
|
|
|
|
flags = fcntl(fd, F_GETFL, 0);
|
|
result = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
|
|
|
|
return result;
|
|
}
|
|
#endif
|
|
|
|
void sh_set_timeout(int second)
|
|
{
|
|
timeout = second;
|
|
}
|
|
/* Elenoa MOD : END */
|
|
|
|
int get_psl_from_cache(PSERVICE_STRUCT *psl)
|
|
{
|
|
int nCount = 0;
|
|
FILE* fp=NULL;
|
|
int i=0;
|
|
int numread=0;
|
|
|
|
if (strlen(szCacheFile) == 0)
|
|
return 0;
|
|
|
|
fp = fopen(szCacheFile,"rb");
|
|
|
|
if(fp)
|
|
{
|
|
fread(&nCount,sizeof(int),1,fp);
|
|
|
|
*psl = malloc(sizeof(SERVICE_STRUCT) * nCount);
|
|
numread = fread(*psl,sizeof(SERVICE_STRUCT) * nCount,1,fp);
|
|
|
|
if (numread < 1)
|
|
{
|
|
SetLastError(SHERRNO_INVALIDCACHEFILE);
|
|
return 0;
|
|
}
|
|
|
|
fclose(fp);
|
|
}
|
|
return nCount;
|
|
}
|
|
|
|
int set_psl_to_cache(PSERVICE_STRUCT *psl,int nCount)
|
|
{
|
|
FILE* fp=NULL;
|
|
int i=0;
|
|
|
|
if (strlen(szCacheFile) == 0)
|
|
return 0;
|
|
|
|
fp = fopen(szCacheFile,"wb");
|
|
|
|
if (fp)
|
|
{
|
|
fwrite(&nCount,sizeof(int),1,fp);
|
|
|
|
fwrite(*psl,sizeof(SERVICE_STRUCT)*nCount,1,fp);
|
|
fclose(fp);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
time_t get_time_from_sntp()
|
|
{
|
|
char szHost[128];
|
|
int nRecv;
|
|
time_sync_t tst;
|
|
int nWrite;
|
|
time_sync_t *pSyncInfo = NULL;
|
|
#ifdef WIN32
|
|
struct tm *ttm=NULL;
|
|
#endif
|
|
SOCKET sock;
|
|
struct sockaddr_in sa;
|
|
long ltime;
|
|
|
|
ltime = (long)time(NULL);
|
|
|
|
if (ne_sock_init() != NE_OK)
|
|
{
|
|
return ltime;
|
|
}
|
|
|
|
// Get server time
|
|
strcpy(szHost, SNTP_DOMAIN);
|
|
if (isalpha(szHost[0]))
|
|
{
|
|
struct hostent *phe = gethostbyname(szHost);
|
|
if (!phe)
|
|
{
|
|
return ltime;
|
|
}
|
|
|
|
sprintf(szHost, "%d.%d.%d.%d",
|
|
(unsigned char)*(phe->h_addr_list[0]), (unsigned char)*(phe->h_addr_list[0] + 1),
|
|
(unsigned char)*(phe->h_addr_list[0] + 2), (unsigned char)*(phe->h_addr_list[0] + 3));
|
|
}
|
|
|
|
sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
|
|
if (sock == INVALID_SOCKET)
|
|
{
|
|
return ltime;
|
|
}
|
|
|
|
sa.sin_family = AF_INET;
|
|
sa.sin_addr.s_addr = inet_addr(szHost);
|
|
sa.sin_port = htons(SNTP_PORT);
|
|
|
|
#ifdef WIN32
|
|
__nonblock_win32(sock);
|
|
|
|
if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) == SOCKET_ERROR)
|
|
{
|
|
|
|
if (WSAEWOULDBLOCK == WSAGetLastError())
|
|
{
|
|
fd_set wfd, efd;
|
|
struct timeval tv;
|
|
FD_ZERO(&wfd);
|
|
FD_ZERO(&efd);
|
|
FD_SET(sock, &wfd);
|
|
FD_SET(sock, &efd);
|
|
tv.tv_sec = timeout;
|
|
tv.tv_usec = 0;
|
|
nRecv = select(0, 0, &wfd, &efd,&tv);
|
|
if (SOCKET_ERROR == nRecv || 0 == nRecv)
|
|
{
|
|
int nRet = WSAGetLastError();
|
|
return ltime;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return ltime;
|
|
}
|
|
}
|
|
|
|
#else
|
|
__nonblock(sock);
|
|
{
|
|
int i, nRet;
|
|
for (i = 0; i < (timeout * 10); i++) {
|
|
if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) != SOCKET_ERROR) {
|
|
errno = 0;
|
|
break;
|
|
} else {
|
|
nRet = errno;
|
|
}
|
|
if (errno == EISCONN)
|
|
break;
|
|
|
|
if (((i + 1) % 10) == 0) {
|
|
shutdown(sock, 2);
|
|
//close(sock);
|
|
//fprintf(stderr, "RETRY ");
|
|
}
|
|
usleep(100000);
|
|
//fprintf(stderr, "CLI %d\n", i);
|
|
}
|
|
|
|
if (errno != EISCONN && errno != 0)
|
|
{
|
|
return ltime;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
tst.sync_info = ltime + AUTHPRIME - (ltime % AUTHPRIME);
|
|
|
|
tst.sync_info = htonl(tst.sync_info);
|
|
nWrite = _sh_send(sock, (char *)&tst, sizeof(tst));
|
|
|
|
if(nWrite < 0)
|
|
{
|
|
closesocket(sock);
|
|
return ltime;
|
|
}
|
|
|
|
nRecv = _sh_recv(sock, szHost, sizeof(szHost));
|
|
|
|
if (nRecv < 4)
|
|
{
|
|
closesocket(sock);
|
|
return ltime;
|
|
}
|
|
|
|
pSyncInfo = (time_sync_t *)&szHost;
|
|
pSyncInfo->sync_info = ntohl(pSyncInfo->sync_info);
|
|
|
|
// ttm = gmtime((time_t*)&pSyncInfo->sync_info);
|
|
|
|
closesocket(sock);
|
|
|
|
return pSyncInfo->sync_info;
|
|
}
|
|
|
|
char* get_address(const char *userId, const char *password, const char *serviceId,int nFlag)
|
|
{
|
|
// define varialbles
|
|
char *pszResult = NULL;
|
|
|
|
char szMD5[256], szVerifyKey[256], szPassword[128], szAuth[256];
|
|
__int64 nRandom;
|
|
struct tm *ptmNow = NULL;
|
|
time_t tmtNow;
|
|
|
|
COMMAND_STRUCT cmd;
|
|
|
|
PSERVICE_STRUCT psl = NULL;
|
|
int i, nServiceCount = 0;
|
|
|
|
char szHost[30];
|
|
SOCKET sock = INVALID_SOCKET;
|
|
struct sockaddr_in sa;
|
|
BOOL bIsCache = FALSE;
|
|
|
|
// get current time & random number
|
|
if (ne_sock_init() != NE_OK)
|
|
{
|
|
SetLastError(GetLastError());
|
|
bIsCache = TRUE;
|
|
goto CACHE_FUNCTION;
|
|
// return NULL;
|
|
}
|
|
|
|
tmtNow = get_time_from_sntp();
|
|
|
|
srand((unsigned int)tmtNow);
|
|
nRandom = rand() * rand();
|
|
|
|
ptmNow = gmtime((const time_t *)&tmtNow);
|
|
|
|
tmtNow %= 10000000000; // MAX 10
|
|
nRandom %= 10000000000; // MAX 10
|
|
|
|
// create command struct
|
|
#ifdef WIN32
|
|
sprintf(szMD5, "%010d%010I64d%s%s", tmtNow, nRandom, PRIVATE_KEY, SERVER_NAME);
|
|
#else
|
|
sprintf(szMD5, "%010d%010lld%s%s", (int)tmtNow, nRandom, PRIVATE_KEY, SERVER_NAME);
|
|
#endif
|
|
ne_md5_buffer(szMD5, szVerifyKey);
|
|
|
|
ne_md5_buffer(password, szPassword);
|
|
sprintf(szMD5, "%s%s%d", userId, szPassword, (int)tmtNow);
|
|
ne_md5_buffer(szMD5, szPassword);
|
|
|
|
sprintf(szAuth, "%s%c%s%c%d", userId, DELIMITER, szPassword, DELIMITER, (int)tmtNow);
|
|
|
|
// Make header
|
|
#ifdef WIN32
|
|
memset((void *)&cmd, NULL, sizeof(cmd));
|
|
sprintf(cmd.szTranId, "%04d%02d%02d%02d%02d%02d-%.10s-%010d-%010I64d",
|
|
#else
|
|
memset((void *)&cmd, 0, sizeof(cmd));
|
|
sprintf(cmd.szTranId, "%04d%02d%02d%02d%02d%02d-%.10s-%010d-%010lld",
|
|
#endif
|
|
ptmNow->tm_year + 1900, ptmNow->tm_mon, ptmNow->tm_wday, ptmNow->tm_hour, ptmNow->tm_min, ptmNow->tm_sec,
|
|
szVerifyKey, (int)tmtNow, nRandom);
|
|
|
|
cmd.nMode = htonl(0x0080);
|
|
strcpy(cmd.szIssuer, SERVER_NAME);
|
|
cmd.nLength = htonl((u_long)strlen(szAuth));
|
|
|
|
// create socket
|
|
strcpy(szHost, CENTER_HOST);
|
|
if (isalpha(szHost[0])) {
|
|
struct hostent *phe = gethostbyname(szHost);
|
|
if (!phe)
|
|
{
|
|
bIsCache = TRUE;
|
|
goto CACHE_FUNCTION;
|
|
// goto EXIT_FUNCTION;
|
|
}
|
|
|
|
memcpy(&sa.sin_addr, phe->h_addr, sizeof(struct in_addr));
|
|
}
|
|
else
|
|
sa.sin_addr.s_addr = inet_addr(szHost);
|
|
|
|
if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET)
|
|
{
|
|
bIsCache = TRUE;
|
|
goto CACHE_FUNCTION;
|
|
// goto EXIT_FUNCTION;
|
|
}
|
|
|
|
sa.sin_family = AF_INET;
|
|
sa.sin_port = htons(CENTER_PORT);
|
|
|
|
/* Elenoa MOD : START */
|
|
#ifdef _WIN32
|
|
__nonblock_win32(sock);
|
|
|
|
if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) == SOCKET_ERROR)
|
|
{
|
|
|
|
if (WSAEWOULDBLOCK == WSAGetLastError())
|
|
{
|
|
fd_set wfd, efd;
|
|
struct timeval tv;
|
|
int result;
|
|
FD_ZERO(&wfd);
|
|
FD_ZERO(&efd);
|
|
FD_SET(sock, &wfd);
|
|
FD_SET(sock, &efd);
|
|
tv.tv_sec = timeout;
|
|
tv.tv_usec = 0;
|
|
result = select(0, 0, &wfd, &efd,&tv);
|
|
if (SOCKET_ERROR == result || 0 == result)
|
|
{
|
|
int nRet = WSAGetLastError();
|
|
// goto EXIT_FUNCTION;
|
|
bIsCache = TRUE;
|
|
goto CACHE_FUNCTION;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bIsCache = TRUE;
|
|
goto CACHE_FUNCTION;
|
|
// goto EXIT_FUNCTION;
|
|
}
|
|
}
|
|
|
|
#else
|
|
__nonblock(sock);
|
|
{
|
|
int i;
|
|
for (i = 0; i < (timeout * 10); i++) {
|
|
if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) != SOCKET_ERROR) {
|
|
errno = 0;
|
|
break;
|
|
}
|
|
if (errno == EISCONN)
|
|
break;
|
|
|
|
if (((i + 1) % 10) == 0)
|
|
{
|
|
shutdown(sock, 2);
|
|
//close(sock);
|
|
}
|
|
usleep(100000);
|
|
//fprintf(stderr, "%d\n", i);
|
|
}
|
|
|
|
if (errno != EISCONN && errno != 0)
|
|
{
|
|
bIsCache = TRUE;
|
|
goto CACHE_FUNCTION;
|
|
// goto EXIT_FUNCTION;
|
|
}
|
|
}
|
|
#endif
|
|
// Send packet
|
|
if (_sh_send(sock, (char *)&cmd, sizeof(cmd)) == SOCKET_ERROR)
|
|
{
|
|
bIsCache = TRUE;
|
|
goto CACHE_FUNCTION;
|
|
// goto EXIT_FUNCTION;
|
|
}
|
|
|
|
if (_sh_send(sock, szAuth, (int)strlen(szAuth)) == SOCKET_ERROR)
|
|
{
|
|
bIsCache = TRUE;
|
|
goto CACHE_FUNCTION;
|
|
// goto EXIT_FUNCTION;
|
|
}
|
|
|
|
if (_sh_recv(sock, (char*)&cmd, sizeof(cmd)) == SOCKET_ERROR)
|
|
{
|
|
bIsCache = TRUE;
|
|
goto CACHE_FUNCTION;
|
|
// goto EXIT_FUNCTION;
|
|
}
|
|
|
|
cmd.nLength = ntohl(cmd.nLength);
|
|
cmd.nResult = ntohl(cmd.nResult);
|
|
if (cmd.nResult != 0x1000) {
|
|
if (cmd.nResult == 0x3000)
|
|
SetLastError(SHERRNO_UNDEFINED);
|
|
else if (cmd.nResult == 0x3001)
|
|
SetLastError(SHERRNO_AUTHORIZATION);
|
|
else if (cmd.nResult == 0x9000)
|
|
SetLastError(SHERRNO_INTERNAL);
|
|
|
|
bIsCache = TRUE;
|
|
goto CACHE_FUNCTION;
|
|
// goto EXIT_FUNCTION;
|
|
}
|
|
|
|
if (_sh_recv(sock, (char*)&nServiceCount, 4) == SOCKET_ERROR)
|
|
{
|
|
bIsCache = TRUE;
|
|
goto CACHE_FUNCTION;
|
|
// goto EXIT_FUNCTION;
|
|
}
|
|
|
|
nServiceCount = ntohl(nServiceCount);
|
|
psl = malloc(sizeof(SERVICE_STRUCT) * nServiceCount);
|
|
|
|
if (!psl)
|
|
goto EXIT_FUNCTION;
|
|
|
|
if (_sh_recv(sock, (char*)psl, sizeof(SERVICE_STRUCT) * nServiceCount) == SOCKET_ERROR)
|
|
{
|
|
bIsCache = TRUE;
|
|
if (psl)
|
|
free(psl);
|
|
goto CACHE_FUNCTION;
|
|
// goto EXIT_FUNCTION;
|
|
}
|
|
|
|
closesocket(sock);
|
|
sock = INVALID_SOCKET;
|
|
|
|
set_psl_to_cache(&psl,nServiceCount); // ij½¬ÆÄÀÏ¿¡ ±â·Ï
|
|
|
|
CACHE_FUNCTION:
|
|
|
|
if( bIsCache)
|
|
nServiceCount = get_psl_from_cache(&psl);
|
|
|
|
for (i = 0; i < nServiceCount; i++) {
|
|
if (strcmp((const char *)psl[i].id, serviceId) == 0)
|
|
{
|
|
switch(nFlag)
|
|
{
|
|
case 0: // dav address
|
|
strcat(psl[i].domain2, "/dav");
|
|
pszResult = strdup((const char *)psl[i].domain2);
|
|
break;
|
|
case 1: // rcts adress
|
|
pszResult = strdup((const char *)psl[i].domain);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!pszResult)
|
|
SetLastError(SHERRNO_NOSERVICE);
|
|
|
|
EXIT_FUNCTION:
|
|
i = GetLastError();
|
|
|
|
if (psl)
|
|
free(psl);
|
|
|
|
if (sock != INVALID_SOCKET)
|
|
closesocket(sock);
|
|
|
|
SetLastError(i);
|
|
|
|
return pszResult;
|
|
}
|
|
|
|
const char *sh_get_service_host(const char *userId, const char *password, const char *serviceId)
|
|
{
|
|
return get_address(userId,password,serviceId,0);
|
|
}
|
|
|
|
const char *sh_get_rcts_host(const char *userId, const char *password, const char *serviceId)
|
|
{
|
|
return get_address(userId,password,serviceId,1);
|
|
}
|
|
|
|
const int sh_get_service_info(const char *userId, const char *password, const char *serviceId, PINT64 totalSpace, PINT64 freeSpace)
|
|
{
|
|
// define varialbles
|
|
int nResult = 0;
|
|
|
|
char szMD5[256], szVerifyKey[256], szPassword[128], szAuth[256];
|
|
__int64 nRandom;
|
|
struct tm *ptmNow = NULL;
|
|
time_t tmtNow;
|
|
char* pdata;
|
|
|
|
COMMAND_STRUCT cmd;
|
|
|
|
char szRecvBuf[1024], *pszUsedSpace;
|
|
int i;
|
|
|
|
SOCKET sock = INVALID_SOCKET;
|
|
struct sockaddr_in sa;
|
|
|
|
char* pszHost = (char *)sh_get_rcts_host(userId, password, serviceId);
|
|
|
|
if (!pszHost)
|
|
return 0;
|
|
|
|
pdata = strstr(pszHost,"/");
|
|
|
|
if (pdata)
|
|
*pdata = 0x00;
|
|
|
|
// get current time & random number
|
|
tmtNow = get_time_from_sntp();
|
|
|
|
// tmtNow = time(NULL);
|
|
|
|
srand((unsigned int)tmtNow);
|
|
nRandom = rand() * rand();
|
|
|
|
ptmNow = gmtime((const time_t *)&tmtNow);
|
|
|
|
tmtNow %= 10000000000; // MAX 10
|
|
nRandom %= 10000000000; // MAX 10
|
|
|
|
// create command struct
|
|
#ifdef WIN32
|
|
sprintf(szMD5, "%010d%010I64d%s%s", tmtNow, nRandom, PRIVATE_KEY, SERVER_NAME);
|
|
#else
|
|
sprintf(szMD5, "%010d%010lld%s%s", (int)tmtNow, nRandom, PRIVATE_KEY, SERVER_NAME);
|
|
#endif
|
|
ne_md5_buffer(szMD5, szVerifyKey);
|
|
|
|
ne_md5_buffer(password, szPassword);
|
|
sprintf(szMD5, "%s@%s%s%d", serviceId, userId, szPassword, (int)tmtNow);
|
|
ne_md5_buffer(szMD5, szPassword);
|
|
|
|
sprintf(szAuth, "%s@%s%c%s%c%d", serviceId, userId, DELIMITER, szPassword, DELIMITER, (int)tmtNow);
|
|
|
|
// Make header
|
|
|
|
#ifdef WIN32
|
|
memset((void *)&cmd, NULL, sizeof(cmd));
|
|
sprintf(cmd.szTranId, "%04d%02d%02d%02d%02d%02d-%.10s-%010d-%010I64d",
|
|
#else
|
|
memset((void *)&cmd, 0, sizeof(cmd));
|
|
sprintf(cmd.szTranId, "%04d%02d%02d%02d%02d%02d-%.10s-%010d-%010lld",
|
|
#endif
|
|
ptmNow->tm_year + 1900, ptmNow->tm_mon+1, ptmNow->tm_mday, ptmNow->tm_hour, ptmNow->tm_min, ptmNow->tm_sec,
|
|
szVerifyKey, (int)tmtNow, nRandom);
|
|
cmd.nMode = htonl(0x0012);
|
|
strcpy(cmd.szIssuer, SERVER_NAME);
|
|
strcpy(cmd.szServiceId, serviceId);
|
|
cmd.nLength = htonl((u_long)strlen(szAuth));
|
|
|
|
// create socket
|
|
if (isalpha(pszHost[0])) {
|
|
struct hostent *phe = gethostbyname(pszHost);
|
|
if (!phe)
|
|
goto EXIT_FUNCTION;
|
|
|
|
memcpy(&sa.sin_addr, phe->h_addr, sizeof(struct in_addr));
|
|
}
|
|
else
|
|
sa.sin_addr.s_addr = inet_addr(pszHost);
|
|
|
|
if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET)
|
|
goto EXIT_FUNCTION;
|
|
|
|
sa.sin_family = AF_INET;
|
|
// sa.sin_addr.s_addr = inet_addr(pszHost);
|
|
sa.sin_port = htons(RESOURCE_PORT);
|
|
|
|
/* Elenoa MOD : START */
|
|
#ifdef _WIN32
|
|
__nonblock_win32(sock);
|
|
|
|
if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) == SOCKET_ERROR)
|
|
{
|
|
|
|
if (WSAEWOULDBLOCK == WSAGetLastError())
|
|
{
|
|
fd_set wfd, efd;
|
|
struct timeval tv;
|
|
int result;
|
|
FD_ZERO(&wfd);
|
|
FD_ZERO(&efd);
|
|
FD_SET(sock, &wfd);
|
|
FD_SET(sock, &efd);
|
|
tv.tv_sec = timeout;
|
|
tv.tv_usec = 0;
|
|
result = select(0, 0, &wfd, &efd,&tv);
|
|
if (SOCKET_ERROR == result || 0 == result)
|
|
{
|
|
int nRet = WSAGetLastError();
|
|
goto EXIT_FUNCTION;
|
|
}
|
|
}
|
|
else
|
|
goto EXIT_FUNCTION;
|
|
}
|
|
|
|
#else
|
|
__nonblock(sock);
|
|
{
|
|
int i;
|
|
for (i = 0; i < (timeout * 10); i++) {
|
|
if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) != SOCKET_ERROR) {
|
|
errno = 0;
|
|
break;
|
|
}
|
|
if (errno == EISCONN)
|
|
break;
|
|
|
|
if (((i + 1) % 10) == 0)
|
|
{
|
|
shutdown(sock, 2);
|
|
close(sock);
|
|
}
|
|
usleep(100000);
|
|
//fprintf(stderr, "%d\n", i);
|
|
}
|
|
|
|
if (errno != EISCONN && errno != 0)
|
|
goto EXIT_FUNCTION;
|
|
}
|
|
#endif
|
|
|
|
// Send packet
|
|
if (_sh_send(sock, (char *)&cmd, sizeof(cmd)) == SOCKET_ERROR)
|
|
goto EXIT_FUNCTION;
|
|
|
|
if (_sh_send(sock, szAuth, (int)strlen(szAuth)) == SOCKET_ERROR)
|
|
goto EXIT_FUNCTION;
|
|
|
|
if (_sh_recv(sock, (char*)&cmd, sizeof(cmd)) == SOCKET_ERROR)
|
|
goto EXIT_FUNCTION;
|
|
|
|
cmd.nLength = ntohl(cmd.nLength);
|
|
cmd.nResult = ntohl(cmd.nResult);
|
|
if (cmd.nResult != 0x1000) {
|
|
if (cmd.nResult == 0x3000)
|
|
SetLastError(SHERRNO_UNDEFINED);
|
|
else if (cmd.nResult == 0x3001)
|
|
SetLastError(SHERRNO_AUTHORIZATION);
|
|
else if (cmd.nResult == 0x9000)
|
|
SetLastError(SHERRNO_INTERNAL);
|
|
goto EXIT_FUNCTION;
|
|
}
|
|
|
|
if (_sh_recv(sock, szRecvBuf, cmd.nLength) == SOCKET_ERROR)
|
|
goto EXIT_FUNCTION;
|
|
|
|
closesocket(sock);
|
|
sock = INVALID_SOCKET;
|
|
|
|
pszUsedSpace = strchr(szRecvBuf, DELIMITER);
|
|
*(pszUsedSpace++) = (char)NULL;
|
|
|
|
#ifdef WIN32
|
|
*totalSpace = _atoi64(szRecvBuf);
|
|
*freeSpace = *totalSpace - _atoi64(pszUsedSpace);
|
|
#else
|
|
*totalSpace = strtoll(szRecvBuf, NULL, 10);
|
|
*freeSpace = *totalSpace - strtoll(pszUsedSpace, NULL, 10);
|
|
#endif
|
|
|
|
nResult = 1;
|
|
|
|
EXIT_FUNCTION:
|
|
i = GetLastError();
|
|
|
|
if (pszHost)
|
|
free(pszHost);
|
|
|
|
if (sock != INVALID_SOCKET)
|
|
closesocket(sock);
|
|
|
|
// ne_sock_exit();
|
|
|
|
SetLastError(i);
|
|
|
|
return nResult;
|
|
}
|
|
|
|
LPTRANSFER_LOG_DATA sh_get_transfer_log_list(const char *userId, const char *password, const char *serviceId,
|
|
const char* szSessionID,time_t sTime, time_t eTime,int nDelete,int nDirection)
|
|
{
|
|
|
|
LPTRANSFER_LOG_DATA pLogFirst=NULL;
|
|
// define varialbles
|
|
|
|
char szMD5[256], szVerifyKey[256], szPassword[128], szAuth[256];
|
|
__int64 nRandom;
|
|
struct tm *ptmNow = NULL;
|
|
time_t tmtNow;
|
|
#ifdef WIN32
|
|
char* pdata;
|
|
#endif
|
|
struct transfer_log_data tld;
|
|
COMMAND_STRUCT cmd;
|
|
int i,nRet;
|
|
LPTRANSFER_LOG_DATA pLogPrev=NULL;
|
|
struct get_transfer_log gtl;
|
|
|
|
SOCKET sock = INVALID_SOCKET;
|
|
struct sockaddr_in sa;
|
|
char* pszBody=NULL;
|
|
char* pszBuffer;
|
|
char szHost[30];
|
|
#ifdef WIN32
|
|
FILE* file;
|
|
#endif
|
|
|
|
// get current time & random number
|
|
|
|
//printf("Get Time from %s : start\n",SNTP_DOMAIN);
|
|
tmtNow = get_time_from_sntp();
|
|
//printf("Get Time from %s : end\n",SNTP_DOMAIN);
|
|
|
|
srand((unsigned int)tmtNow);
|
|
nRandom = rand() * rand();
|
|
|
|
ptmNow = gmtime((const time_t *)&tmtNow);
|
|
|
|
tmtNow %= 10000000000; // MAX 10
|
|
nRandom %= 10000000000; // MAX 10
|
|
|
|
// create command struct
|
|
#ifdef WIN32
|
|
sprintf(szMD5, "%010d%010I64d%s%s", tmtNow, nRandom, PRIVATE_KEY, SERVER_NAME);
|
|
#else
|
|
sprintf(szMD5, "%010d%010lld%s%s", (int)tmtNow, nRandom, PRIVATE_KEY, SERVER_NAME);
|
|
#endif
|
|
ne_md5_buffer(szMD5, szVerifyKey);
|
|
|
|
ne_md5_buffer(password, szPassword);
|
|
sprintf(szMD5, "%s%s%d", userId, szPassword, (int)tmtNow);
|
|
ne_md5_buffer(szMD5, szPassword);
|
|
|
|
sprintf(szAuth, "%s%c%s%c%d", userId, DELIMITER, szPassword, DELIMITER, (int)tmtNow);
|
|
|
|
// Make header
|
|
|
|
#ifdef WIN32
|
|
memset((void *)&cmd, NULL, sizeof(cmd));
|
|
sprintf(cmd.szTranId, "%04d%02d%02d%02d%02d%02d-%.10s-%010d-%010I64d",
|
|
#else
|
|
memset((void *)&cmd, 0, sizeof(cmd));
|
|
sprintf(cmd.szTranId, "%04d%02d%02d%02d%02d%02d-%.10s-%010d-%010lld",
|
|
#endif
|
|
ptmNow->tm_year + 1900, ptmNow->tm_mon, ptmNow->tm_wday, ptmNow->tm_hour, ptmNow->tm_min, ptmNow->tm_sec,
|
|
szVerifyKey, (int)tmtNow, nRandom);
|
|
|
|
cmd.nMode = htonl(MSG_MODE_SSDK_GTS_GET_TRANSFER_LOG);
|
|
strcpy(cmd.szIssuer, SERVER_NAME);
|
|
cmd.nLength = htonl((u_long)strlen(szAuth)+sizeof(gtl));
|
|
|
|
switch(nDirection)
|
|
{
|
|
case 0: // upload
|
|
gtl.direction = 'U';
|
|
break;
|
|
case 1: // download
|
|
gtl.direction = 'D';
|
|
break;
|
|
default: // both
|
|
gtl.direction = 'B';
|
|
break;
|
|
}
|
|
|
|
gtl.enddate = ntohl((u_long)eTime);
|
|
gtl.startdate = ntohl((u_long)sTime);
|
|
|
|
if(nDelete ==0)
|
|
gtl.is_delete = 'N';
|
|
else
|
|
gtl.is_delete = 'Y';
|
|
|
|
ne_md5_buffer(szSessionID,gtl.sessionkey);
|
|
//fprintf(stderr, "%s\n", gtl.sessionkey);
|
|
strcpy(gtl.volumeid,serviceId);
|
|
|
|
// create socket
|
|
strcpy(szHost, CENTER_HOST);
|
|
if (isalpha(szHost[0])) {
|
|
struct hostent *phe = gethostbyname(szHost);
|
|
if (!phe)
|
|
goto EXIT_FUNCTION;
|
|
|
|
memcpy(&sa.sin_addr, phe->h_addr, sizeof(struct in_addr));
|
|
}
|
|
else
|
|
sa.sin_addr.s_addr = inet_addr(szHost);
|
|
|
|
if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET)
|
|
goto EXIT_FUNCTION;
|
|
|
|
|
|
sa.sin_family = AF_INET;
|
|
sa.sin_port = htons(GTLLOG_PORT);
|
|
|
|
/* Elenoa MOD : START */
|
|
#ifdef _WIN32
|
|
__nonblock_win32(sock);
|
|
|
|
if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) == SOCKET_ERROR)
|
|
{
|
|
|
|
if (WSAEWOULDBLOCK == WSAGetLastError())
|
|
{
|
|
fd_set wfd, efd;
|
|
struct timeval tv;
|
|
int result;
|
|
FD_ZERO(&wfd);
|
|
FD_ZERO(&efd);
|
|
FD_SET(sock, &wfd);
|
|
FD_SET(sock, &efd);
|
|
tv.tv_sec = timeout;
|
|
tv.tv_usec = 0;
|
|
result = select(0, 0, &wfd, &efd,&tv);
|
|
if (SOCKET_ERROR == result || 0 == result)
|
|
{
|
|
int nRet = WSAGetLastError();
|
|
goto EXIT_FUNCTION;
|
|
}
|
|
}
|
|
else
|
|
goto EXIT_FUNCTION;
|
|
}
|
|
|
|
#else
|
|
__nonblock(sock);
|
|
{
|
|
int i;
|
|
for (i = 0; i < (timeout * 10); i++) {
|
|
if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) != SOCKET_ERROR) {
|
|
errno = 0;
|
|
break;
|
|
}
|
|
if (errno == EISCONN)
|
|
break;
|
|
|
|
if (((i + 1) % 10) == 0)
|
|
{
|
|
shutdown(sock, 2);
|
|
close(sock);
|
|
if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET)
|
|
goto EXIT_FUNCTION;
|
|
}
|
|
usleep(100000);
|
|
//fprintf(stderr, "%d\n", i);
|
|
}
|
|
|
|
if (errno != EISCONN && errno != 0)
|
|
goto EXIT_FUNCTION;
|
|
}
|
|
#endif
|
|
|
|
if (_sh_send(sock, (char *)&cmd, sizeof(cmd)) == SOCKET_ERROR)
|
|
goto EXIT_FUNCTION;
|
|
|
|
pszBody = (char*)malloc(strlen(szAuth)+sizeof(gtl));
|
|
strcpy(pszBody,szAuth);
|
|
memcpy(pszBody+strlen(szAuth),>l,sizeof(gtl));
|
|
|
|
if (_sh_send(sock, pszBody,(int)strlen(szAuth)+sizeof(gtl)) == SOCKET_ERROR)
|
|
goto EXIT_FUNCTION;
|
|
/*
|
|
if (_sh_recv(sock, (char*)&cmd, sizeof(cmd)) == SOCKET_ERROR)
|
|
goto EXIT_FUNCTION;
|
|
|
|
cmd.nLength = ntohl(cmd.nLength);
|
|
cmd.nResult = ntohl(cmd.nResult);
|
|
if (cmd.nResult != 0x1000) {
|
|
if (cmd.nResult == 0x3000)
|
|
SetLastError(SHERRNO_UNDEFINED);
|
|
else if (cmd.nResult == 0x3001)
|
|
SetLastError(SHERRNO_AUTHORIZATION);
|
|
else if (cmd.nResult == 0x9000)
|
|
SetLastError(SHERRNO_INTERNAL);
|
|
goto EXIT_FUNCTION;
|
|
}
|
|
*/
|
|
tld.total_message_number = 0;
|
|
i = 1;
|
|
|
|
do
|
|
{
|
|
//fprintf(stderr, "WAIT TO RECEIVE HEADER\n");
|
|
if (_sh_recv(sock, (char*)&cmd, sizeof(cmd)) == SOCKET_ERROR)
|
|
goto EXIT_FUNCTION;
|
|
|
|
cmd.nLength = ntohl(cmd.nLength);
|
|
cmd.nResult = ntohl(cmd.nResult);
|
|
cmd.nMode = ntohl(cmd.nMode);
|
|
|
|
if(cmd.nMode != MSG_MODE_GTS_SSDK_SEND_TRANSFER_LOG)
|
|
goto EXIT_FUNCTION;
|
|
|
|
if(cmd.nLength <=0 )
|
|
goto EXIT_FUNCTION;
|
|
|
|
pszBuffer = (char*)malloc(cmd.nLength);
|
|
|
|
//fprintf(stderr, "WAIT TO RECEIVE BODY\n");
|
|
if (_sh_recv(sock, pszBuffer,cmd.nLength) == SOCKET_ERROR)
|
|
goto EXIT_FUNCTION;
|
|
|
|
memcpy(&tld.total_message_number,pszBuffer,sizeof(int));
|
|
memcpy(&tld.current_message_number,pszBuffer + sizeof(tld.total_message_number),sizeof(tld.current_message_number));
|
|
memcpy(tld.sessionid,pszBuffer + sizeof(tld.current_message_number) + sizeof(tld.total_message_number),sizeof(tld.sessionid));
|
|
memcpy(tld.filename,pszBuffer + sizeof(tld.current_message_number) + sizeof(tld.total_message_number) +
|
|
sizeof(tld.sessionid),sizeof(tld.filename));
|
|
memcpy(&tld.length,pszBuffer + sizeof(tld.current_message_number) + sizeof(tld.total_message_number) +
|
|
sizeof(tld.sessionid) + sizeof(tld.filename),sizeof(tld.length));
|
|
memcpy(&tld.startdate,pszBuffer + sizeof(tld.current_message_number) + sizeof(tld.total_message_number) +
|
|
sizeof(tld.sessionid) + sizeof(tld.filename) + sizeof(tld.length),sizeof(tld.startdate));
|
|
memcpy(&tld.enddate,pszBuffer + sizeof(tld.current_message_number) + sizeof(tld.total_message_number) +
|
|
sizeof(tld.sessionid) + sizeof(tld.filename) + sizeof(tld.length) + sizeof(tld.startdate),sizeof(tld.enddate));
|
|
memcpy(&tld.respcode,pszBuffer + sizeof(tld.current_message_number) + sizeof(tld.total_message_number) +
|
|
sizeof(tld.sessionid) + sizeof(tld.filename) + sizeof(tld.length) + sizeof(tld.startdate) + sizeof(tld.enddate), sizeof(tld.respcode));
|
|
memcpy(&tld.direction,pszBuffer + sizeof(tld.current_message_number) + sizeof(tld.total_message_number) +
|
|
sizeof(tld.sessionid) + sizeof(tld.filename) + sizeof(tld.length) + sizeof(tld.startdate) + sizeof(tld.enddate) + sizeof(tld.respcode),sizeof(tld.direction));
|
|
|
|
free(pszBuffer);
|
|
|
|
tld.total_message_number = ntohl(tld.total_message_number);
|
|
tld.current_message_number = ntohl(tld.current_message_number);
|
|
tld.enddate = ntohl(tld.enddate);
|
|
tld.startdate = ntohl((u_long)tld.startdate);
|
|
tld.respcode = ntohl((u_long)tld.respcode);
|
|
|
|
//fprintf(stderr, "GET ONE\n");
|
|
|
|
if(tld.total_message_number == 0)
|
|
goto EXIT_FUNCTION;
|
|
|
|
{
|
|
#if 0 // Elenoa: OLD CODE
|
|
cmd.nMode = htonl(MSG_MODE_SSDK_GTS_SEND_TRANSFER_LOG_RESP);
|
|
strcpy(cmd.szIssuer, SERVER_NAME);
|
|
strcpy(cmd.szServiceId, serviceId);
|
|
cmd.nLength = htonl(sizeof(int));
|
|
|
|
if (_sh_send(sock, (char *)&cmd, sizeof(cmd)) == SOCKET_ERROR)
|
|
goto EXIT_FUNCTION;
|
|
|
|
nRet = htonl(0);
|
|
|
|
if (_sh_send(sock, (char*)&nRet, sizeof(int)) == SOCKET_ERROR)
|
|
goto EXIT_FUNCTION;
|
|
#endif
|
|
PCOMMAND_STRUCT pcmd;
|
|
char sendbuf[512];
|
|
|
|
memset(sendbuf, 0, 511);
|
|
pcmd = sendbuf;
|
|
pcmd->nMode = htonl(MSG_MODE_SSDK_GTS_SEND_TRANSFER_LOG_RESP);
|
|
strcpy(pcmd->szIssuer, SERVER_NAME);
|
|
strcpy(pcmd->szServiceId, serviceId);
|
|
pcmd->nLength = htonl(sizeof(int));
|
|
*((int *)(sendbuf + sizeof(COMMAND_STRUCT))) = htonl(0);
|
|
|
|
if (_sh_send(sock, (char *)pcmd, sizeof(COMMAND_STRUCT) + sizeof(int)) == SOCKET_ERROR)
|
|
goto EXIT_FUNCTION;
|
|
}
|
|
//fprintf(stderr, "SEND RESEND\n");
|
|
{
|
|
LPTRANSFER_LOG_DATA pLog;
|
|
pLog = (LPTRANSFER_LOG_DATA)malloc(sizeof(TRANSFER_LOG_DATA));
|
|
|
|
if(!pLogFirst)
|
|
pLogFirst = pLog;
|
|
else
|
|
pLogPrev->pnext = pLog;
|
|
|
|
pLog->sessionid = (char*)malloc(TL_SESSION+1);
|
|
pLog->filename = (char*)malloc(TL_FILENAME+1);
|
|
pLog->pnext = NULL;
|
|
pLogPrev = pLog;
|
|
|
|
switch(tld.direction)
|
|
{
|
|
case 'u': case 'U':
|
|
pLog->ndirection = 0;
|
|
break;
|
|
case 'd': case 'D':
|
|
pLog->ndirection = 1;
|
|
break;
|
|
default:
|
|
pLog->ndirection = 2;
|
|
break;
|
|
}
|
|
strcpy(pLog->sessionid,tld.sessionid);
|
|
strcpy(pLog->filename,tld.filename);
|
|
pLog->enddate = tld.enddate;
|
|
pLog->length = tld.length;
|
|
pLog->startdate = tld.startdate;
|
|
//fprintf(stderr, "LOOP\n");
|
|
}
|
|
i++;
|
|
}while(i <= tld.total_message_number);
|
|
|
|
EXIT_FUNCTION:
|
|
//fprintf(stderr, "ABOUT TO EXIT FUNCTION\n");
|
|
|
|
if (sock != INVALID_SOCKET)
|
|
closesocket(sock);
|
|
|
|
if(pszBody)
|
|
free(pszBody);
|
|
|
|
return pLogFirst;
|
|
}
|
|
|
|
void sh_free_transfer_log(LPTRANSFER_LOG_DATA ploglist)
|
|
{
|
|
LPTRANSFER_LOG_DATA pLogNext;
|
|
|
|
if (!ploglist)
|
|
return;
|
|
|
|
pLogNext = ploglist->pnext;
|
|
|
|
while(pLogNext)
|
|
{
|
|
pLogNext = ploglist->pnext;
|
|
free(ploglist->sessionid);
|
|
free(ploglist->filename);
|
|
free(ploglist);
|
|
ploglist = pLogNext;
|
|
}
|
|
}
|
|
|
|
|
|
const char* sh_get_uri_by_filename(const char* szHost, const char *userId, const char *password,
|
|
const char* uri,int ncount, int nexpire)
|
|
{
|
|
// define varialbles
|
|
char* pszResult = NULL;
|
|
|
|
char szMD5[256], szVerifyKey[256], szPassword[128], szAuth[256],szTemp[256];
|
|
__int64 nRandom;
|
|
struct tm *ptmNow = NULL;
|
|
struct tm *ptmexpire = NULL;
|
|
time_t tmtNow;
|
|
time_t texpire;
|
|
|
|
COMMAND_STRUCT cmd;
|
|
|
|
char *pszRecvBuf=NULL;
|
|
|
|
SOCKET sock = INVALID_SOCKET;
|
|
struct sockaddr_in sa;
|
|
|
|
if (ne_sock_init() != NE_OK)
|
|
return NULL;
|
|
|
|
if (szHost == NULL)
|
|
return pszResult;
|
|
|
|
// get current time & random number
|
|
tmtNow = get_time_from_sntp();
|
|
|
|
// tmtNow = time(NULL);
|
|
|
|
srand((unsigned int)tmtNow);
|
|
nRandom = rand() * rand();
|
|
|
|
ptmNow = gmtime((const time_t *)&tmtNow);
|
|
|
|
tmtNow %= 10000000000; // MAX 10
|
|
nRandom %= 10000000000; // MAX 10
|
|
|
|
// create command struct
|
|
#ifdef WIN32
|
|
sprintf(szMD5, "%010d%010I64d%s%s", tmtNow, nRandom, PRIVATE_KEY, SERVER_NAME);
|
|
#else
|
|
sprintf(szMD5, "%010d%010lld%s%s", (int)tmtNow, nRandom, PRIVATE_KEY, SERVER_NAME);
|
|
#endif
|
|
ne_md5_buffer(szMD5, szVerifyKey);
|
|
|
|
sprintf(szTemp,"%saFH ;WQGFVKHJFIUW-Odxfhwqg5ogh p[wv,m'vbonniqpf2yr89cyf",password);
|
|
|
|
ne_md5_buffer(szTemp, szPassword);
|
|
|
|
texpire = get_time_from_sntp() + nexpire * 24 * 60 * 60;
|
|
ptmexpire = gmtime((const time_t *)&texpire);
|
|
|
|
sprintf(szAuth, "%s@%s%c%s%c%d%c%s%c%d%c%04d-%02d-%02d", userId, userId, DELIMITER, szPassword, DELIMITER, (int)tmtNow,
|
|
DELIMITER,uri,DELIMITER,ncount,DELIMITER,ptmexpire->tm_year + 1900,ptmexpire->tm_mon+1,ptmexpire->tm_mday);
|
|
|
|
// Make header
|
|
#ifdef WIN32
|
|
memset((void *)&cmd, NULL, sizeof(cmd));
|
|
sprintf(cmd.szTranId, "%04d%02d%02d%02d%02d%02d-%.10s-%010d-%010I64d",
|
|
#else
|
|
memset((void *)&cmd, 0, sizeof(cmd));
|
|
sprintf(cmd.szTranId, "%04d%02d%02d%02d%02d%02d-%.10s-%010d-%010lld",
|
|
#endif
|
|
ptmNow->tm_year + 1900, ptmNow->tm_mon+1, ptmNow->tm_mday, ptmNow->tm_hour, ptmNow->tm_min, ptmNow->tm_sec,szVerifyKey, (int)tmtNow, nRandom);
|
|
|
|
cmd.nMode = htonl(MSG_MODE_GET_FILE_NAME);
|
|
strcpy(cmd.szIssuer, SERVER_NAME);
|
|
strcpy(cmd.szServiceId, userId);
|
|
cmd.nLength = htonl((u_long)strlen(szAuth));
|
|
|
|
// create socket
|
|
if (isalpha(szHost[0])) {
|
|
struct hostent *phe = gethostbyname(szHost);
|
|
if (!phe)
|
|
goto EXIT_FUNCTION;
|
|
|
|
memcpy(&sa.sin_addr, phe->h_addr, sizeof(struct in_addr));
|
|
}
|
|
else
|
|
sa.sin_addr.s_addr = inet_addr(szHost);
|
|
|
|
if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET)
|
|
goto EXIT_FUNCTION;
|
|
|
|
sa.sin_family = AF_INET;
|
|
sa.sin_port = htons(RESOURCE_PORT);
|
|
|
|
/* Elenoa MOD : START */
|
|
#ifdef _WIN32
|
|
__nonblock_win32(sock);
|
|
|
|
if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) == SOCKET_ERROR)
|
|
{
|
|
|
|
if (WSAEWOULDBLOCK == WSAGetLastError())
|
|
{
|
|
fd_set wfd, efd;
|
|
struct timeval tv;
|
|
int result;
|
|
FD_ZERO(&wfd);
|
|
FD_ZERO(&efd);
|
|
FD_SET(sock, &wfd);
|
|
FD_SET(sock, &efd);
|
|
tv.tv_sec = timeout;
|
|
tv.tv_usec = 0;
|
|
result = select(0, 0, &wfd, &efd,&tv);
|
|
if (SOCKET_ERROR == result || 0 == result)
|
|
{
|
|
int nRet = WSAGetLastError();
|
|
goto EXIT_FUNCTION;
|
|
}
|
|
}
|
|
else
|
|
goto EXIT_FUNCTION;
|
|
}
|
|
|
|
#else
|
|
__nonblock(sock);
|
|
{
|
|
int i;
|
|
for (i = 0; i < (timeout * 10); i++) {
|
|
if (connect(sock, (SOCKADDR*)&sa, sizeof(sa)) != SOCKET_ERROR) {
|
|
errno = 0;
|
|
break;
|
|
}
|
|
if (errno == EISCONN)
|
|
break;
|
|
|
|
if (((i + 1) % 10) == 0)
|
|
{
|
|
shutdown(sock, 2);
|
|
close(sock);
|
|
}
|
|
usleep(100000);
|
|
//fprintf(stderr, "%d\n", i);
|
|
}
|
|
|
|
if (errno != EISCONN && errno != 0)
|
|
goto EXIT_FUNCTION;
|
|
}
|
|
#endif
|
|
|
|
// Send packet
|
|
if (_sh_send(sock, (char *)&cmd, sizeof(cmd)) == SOCKET_ERROR)
|
|
goto EXIT_FUNCTION;
|
|
|
|
if (_sh_send(sock, szAuth, (int)strlen(szAuth)) == SOCKET_ERROR)
|
|
goto EXIT_FUNCTION;
|
|
|
|
if (_sh_recv(sock, (char*)&cmd, sizeof(cmd)) == SOCKET_ERROR)
|
|
goto EXIT_FUNCTION;
|
|
|
|
cmd.nLength = ntohl(cmd.nLength);
|
|
cmd.nResult = ntohl(cmd.nResult);
|
|
if (cmd.nResult != 0x1000)
|
|
{
|
|
SetLastError(cmd.nResult);
|
|
goto EXIT_FUNCTION;
|
|
}
|
|
|
|
pszRecvBuf = (char*)malloc(cmd.nLength+1);
|
|
memset(pszRecvBuf,0x00,cmd.nLength+1);
|
|
|
|
if (_sh_recv(sock, pszRecvBuf, cmd.nLength) == SOCKET_ERROR)
|
|
goto EXIT_FUNCTION;
|
|
|
|
closesocket(sock);
|
|
sock = INVALID_SOCKET;
|
|
|
|
SetLastError(GetLastError());
|
|
|
|
EXIT_FUNCTION:
|
|
if (sock != INVALID_SOCKET)
|
|
closesocket(sock);
|
|
|
|
return pszRecvBuf;
|
|
}
|
|
|
|
#ifndef WIN32
|
|
void SetLastError(int nErrCode)
|
|
{
|
|
errno = nErrCode;
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Elenoa MOD START */
|
|
static int _sh_send(SOCKET s, char *pszBuf, int nLen)
|
|
{
|
|
int iSent = 0, nSentLen;
|
|
fd_set wset;
|
|
struct timeval tv;
|
|
|
|
FD_ZERO(&wset);
|
|
FD_SET(s, &wset);
|
|
tv.tv_sec = timeout;
|
|
tv.tv_usec = 0;
|
|
do {
|
|
if (select(s + 1, NULL, &wset, NULL, &tv) < 0) break;
|
|
if (!FD_ISSET(s, &wset)) break;
|
|
|
|
nSentLen = send(s, pszBuf + iSent, nLen, 0);
|
|
|
|
iSent += nSentLen;
|
|
nLen -= nSentLen;
|
|
} while (nLen > 0 && nSentLen > 0);
|
|
|
|
return nLen > 0 ? SOCKET_ERROR : iSent;
|
|
}
|
|
|
|
static int _sh_recv(SOCKET s, char *pszBuf, int nLen)
|
|
{
|
|
int iRecv = 0, nRecvLen;
|
|
fd_set rset;
|
|
struct timeval tv;
|
|
int nRet;
|
|
|
|
FD_ZERO(&rset);
|
|
FD_SET(s, &rset);
|
|
tv.tv_sec = timeout;
|
|
tv.tv_usec = 0;
|
|
do {
|
|
nRet = select(s + 1, &rset, NULL, NULL, &tv);
|
|
|
|
if (nRet <= 0)
|
|
{
|
|
break;
|
|
}
|
|
if (!FD_ISSET(s, &rset)) break;
|
|
|
|
nRecvLen = recv(s, pszBuf + iRecv, nLen, 0);
|
|
|
|
iRecv += nRecvLen;
|
|
nLen -= nRecvLen;
|
|
} while (nLen > 0 && nRecvLen > 0);
|
|
|
|
return nLen < 0 ? SOCKET_ERROR : iRecv;
|
|
}
|
|
|
|
|
|
void sh_set_cache_file(const char *file_path)
|
|
{
|
|
strncpy(szCacheFile,file_path,sizeof(szCacheFile));
|
|
}
|
|
|
|
/* Elenoa MOD END */
|
|
/* Original CODE START *
|
|
static int _sh_send(SOCKET s, char *pszBuf, int nLen)
|
|
{
|
|
int iSent = 0, nSentLen;
|
|
fd_set wset;
|
|
|
|
do {
|
|
nSentLen = send(s, pszBuf + iSent, nLen, 0);
|
|
|
|
iSent += nSentLen;
|
|
nLen -= nSentLen;
|
|
} while (nLen > 0 && nSentLen > 0);
|
|
|
|
return nLen > 0 ? SOCKET_ERROR : iSent;
|
|
}
|
|
*/
|
|
/*
|
|
static int _sh_recv(SOCKET s, char *pszBuf, int nLen)
|
|
{
|
|
int iRecv = 0, nRecvLen;
|
|
do {
|
|
nRecvLen = recv(s, pszBuf + iRecv, nLen, 0);
|
|
|
|
iRecv += nRecvLen;
|
|
nLen -= nRecvLen;
|
|
} while (nLen > 0 && nRecvLen > 0);
|
|
|
|
return nLen < 0 ? SOCKET_ERROR : iRecv;
|
|
}
|
|
* Original CODE END */
|