static int trunk_client_trunk_do_alloc_space(TrackerServerInfo *pTrunkServer, \
const int file_size, FDFSTrunkFullInfo *pTrunkInfo)
{
TrackerHeader *pHeader;
char *p;
int result;
char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+4];
FDFSTrunkInfoBuff trunkBuff;
int64_t in_bytes;
pHeader = (TrackerHeader *)out_buff;
memset(out_buff, 0, sizeof(out_buff));
snprintf(out_buff + sizeof(TrackerHeader), sizeof(out_buff) - \
sizeof(TrackerHeader), "%s", g_group_name);
int2buff(file_size, out_buff + sizeof(TrackerHeader) \
+ FDFS_GROUP_NAME_MAX_LEN);
long2buff(FDFS_GROUP_NAME_MAX_LEN + 4, pHeader->pkg_len);
pHeader->cmd = STORAGE_PROTO_CMD_TRUNK_ALLOC_SPACE;
if ((result=tcpsenddata_nb(pTrunkServer->sock, out_buff, \
sizeof(out_buff), g_fdfs_network_timeout)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"send data to storage server %s:%d fail, " \
"errno: %d, error info: %s", __LINE__, \
pTrunkServer->ip_addr, pTrunkServer->port, \
result, STRERROR(result));
return result;
}
p = (char *)&trunkBuff;
if ((result=fdfs_recv_response(pTrunkServer, \
&p, sizeof(FDFSTrunkInfoBuff), &in_bytes)) != 0)
{
return result;
}
if (in_bytes != sizeof(FDFSTrunkInfoBuff))
{
logError("file: "__FILE__", line: %d, " \
"storage server %s:%d, recv body length: %d invalid, " \
"expect body length: %d", __LINE__, \
pTrunkServer->ip_addr, pTrunkServer->port, \
(int)in_bytes, (int)sizeof(FDFSTrunkInfoBuff));
return EINVAL;
}
pTrunkInfo->path.store_path_index = trunkBuff.store_path_index;
pTrunkInfo->path.sub_path_high = trunkBuff.sub_path_high;
pTrunkInfo->path.sub_path_low = trunkBuff.sub_path_low;
pTrunkInfo->file.id = buff2int(trunkBuff.id);
pTrunkInfo->file.offset = buff2int(trunkBuff.offset);
pTrunkInfo->file.size = buff2int(trunkBuff.size);
pTrunkInfo->status = FDFS_TRUNK_STATUS_HOLD;
return 0;
}
void trunk_file_info_decode(const char *str, FDFSTrunkFileInfo *pTrunkFile)
{
char buff[FDFS_TRUNK_FILE_INFO_LEN];
int len;
base64_decode_auto(&g_fdfs_base64_context, str, FDFS_TRUNK_FILE_INFO_LEN, \
buff, &len);
pTrunkFile->id = buff2int(buff);
pTrunkFile->offset = buff2int(buff + sizeof(int));
pTrunkFile->size = buff2int(buff + sizeof(int) * 2);
}
void trunk_unpack_header(const char *buff, FDFSTrunkHeader *pTrunkHeader)
{
pTrunkHeader->file_type = *(buff + FDFS_TRUNK_FILE_FILE_TYPE_OFFSET);
pTrunkHeader->alloc_size = buff2int(
buff + FDFS_TRUNK_FILE_ALLOC_SIZE_OFFSET);
pTrunkHeader->file_size = buff2int(
buff + FDFS_TRUNK_FILE_FILE_SIZE_OFFSET);
pTrunkHeader->crc32 = buff2int(
buff + FDFS_TRUNK_FILE_FILE_CRC32_OFFSET);
pTrunkHeader->mtime = buff2int(
buff + FDFS_TRUNK_FILE_FILE_MTIME_OFFSET);
memcpy(pTrunkHeader->formatted_ext_name, buff + \
FDFS_TRUNK_FILE_FILE_EXT_NAME_OFFSET, \
FDFS_FILE_EXT_NAME_MAX_LEN + 1);
*(pTrunkHeader->formatted_ext_name+FDFS_FILE_EXT_NAME_MAX_LEN+1)='\0';
}
EmqTypeBlockRequest *emqTypeBlockRequestReStreamLize(char *buff)
{
EmqTypeBlockRequest *tbReq;
if(buff == NULL) {
return NULL;
}
if((tbReq = emqTypeBlockRequestNew()) == NULL)
return NULL;
tbReq->oper_no = buff2int(buff);
tbReq->priority = buff2int(buff+4);
tbReq->send_index = buff2int(buff+8);
tbReq->flag = buff2int(buff+12);
tbReq->body_len = buff2int(buff+16);
return tbReq;
}
/* receive type block request */
EmqTypeBlockResponse * emqTypeBlockResponseReceive(EmqNioConn *the_conn)
{
char buff[1024];
int func_no, ret;
int err_len;
EmqTypeBlockResponse *tpRep;
tpRep = emqTypeBlockResponseNew();
if(tpRep == NULL) {
applog(EMERG, "func emqTypeBlockResponseNew error");
return NULL;
}
memset(buff, 0x00, sizeof(buff));
ret = socketRecvDataFromConn(the_conn, buff, 28);
if(ret != 28 ) {
applog(EMERG, "func socketRecvDataFromConn error!");
emqTypeBlockResponseFree(&tpRep);
return NULL;
}
tpRep->oper_no = buff2int(buff);
tpRep->priority = buff2int(buff+4);
tpRep->send_index = buff2int(buff+8);
tpRep->flag = buff2int(buff+12);
tpRep->body_len = buff2int(buff+16);
tpRep->err_type = buff2int(buff+20);
tpRep->err_no = buff2int(buff+24);
if(!(tpRep->err_type == 0 && tpRep->err_no == 0)) {
memset(buff, 0x00, sizeof(buff));
ret = socketRecvDataFromConn(the_conn, buff, 4);
if(ret != 4 ) {
applog(EMERG, "func socketSendDataToConn error!");
emqTypeBlockResponseFree(&tpRep);
return NULL;
}
err_len= buff2int(buff);
if(err_len > 0 && err_len <= MAX_STR_LEN) {
memset(buff, 0x00, sizeof(buff));
ret = socketRecvDataFromConn(the_conn, buff, err_len);
if(ret != err_len ) {
applog(EMERG, "func socketRecvDataFromConn error!");
emqTypeBlockResponseFree(&tpRep);
return NULL;
}
memcpy(tpRep->err_msg, buff, err_len);
tpRep->err_msg[MAX_STR_LEN] = '\0';
}
}
return tpRep;
}
EmqTypeBlockResponse *emqTypeBlockResponseReStreamLize(char *buff)
{
EmqTypeBlockResponse *tbRes;
int len = 0;
if((tbRes = emqTypeBlockResponseNew()) == NULL)
return NULL;
len += 4;
tbRes->err_type = buff2int(buff+len);
len += 4;
tbRes->err_no = buff2int(buff+len);
len += 4;
if(!(tbRes->err_type == 0 && tbRes->err_no == 0)) {
len += buff2string(buff+len, tbRes->err_msg);
}
tbRes->flag = buff2int(buff+len);
len += 4;
tbRes->body_len = buff2int(buff+len);
return tbRes;
}
MsgExample1Rep *MsgExample1RepReStreamlize(char *buff, int len)
{
MsgExample1Rep *rep;
int len1;
rep = (MsgExample1Rep *)malloc(sizeof(MsgExample1Rep));
if(rep == NULL) {
applog(EMERG, "malloc memory error");
return NULL;
}
rep->allow = buff2int(buff);
return rep;
}
int fdht_recv_header(FDHTServerInfo *pServer, fdht_pkg_size_t *in_bytes)
{
FDHTProtoHeader resp;
int result;
if ((result=tcprecvdata_nb(pServer->sock, &resp, \
sizeof(resp), g_fdht_network_timeout)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"server: %s:%d, recv data fail, " \
"errno: %d, error info: %s", \
__LINE__, pServer->ip_addr, \
pServer->port, \
result, STRERROR(result));
*in_bytes = 0;
return result;
}
if (resp.status != 0)
{
*in_bytes = 0;
return resp.status;
}
*in_bytes = buff2int(resp.pkg_len);
if (*in_bytes < 0)
{
logError("file: "__FILE__", line: %d, " \
"server: %s:%d, recv package size %d " \
"is not correct", \
__LINE__, pServer->ip_addr, \
pServer->port, *in_bytes);
*in_bytes = 0;
return EINVAL;
}
return resp.status;
}
int fdfs_get_storage_ids_from_tracker_server(ConnectionInfo *pTrackerServer)
{
#define MAX_REQUEST_LOOP 32
TrackerHeader *pHeader;
ConnectionInfo *conn;
char out_buff[sizeof(TrackerHeader) + sizeof(int)];
char *p;
char *response;
struct data_info {
char *buffer; //for free
char *content;
int length;
} data_list[MAX_REQUEST_LOOP];
int list_count;
int total_count;
int current_count;
int result;
int i;
int start_index;
int64_t in_bytes;
if ((conn=tracker_connect_server(pTrackerServer, &result)) == NULL)
{
return result;
}
memset(data_list, 0, sizeof(data_list));
memset(out_buff, 0, sizeof(out_buff));
pHeader = (TrackerHeader *)out_buff;
p = out_buff + sizeof(TrackerHeader);
pHeader->cmd = TRACKER_PROTO_CMD_STORAGE_FETCH_STORAGE_IDS;
long2buff(sizeof(int), pHeader->pkg_len);
start_index = 0;
list_count = 0;
result = 0;
while (1)
{
int2buff(start_index, p);
if ((result=tcpsenddata_nb(conn->sock, out_buff, \
sizeof(out_buff), g_fdfs_network_timeout)) != 0)
{
logError("file: "__FILE__", line: %d, " \
"send data to tracker server %s:%d fail, " \
"errno: %d, error info: %s", __LINE__, \
pTrackerServer->ip_addr, \
pTrackerServer->port, \
result, STRERROR(result));
}
else
{
response = NULL;
result = fdfs_recv_response(conn, \
&response, 0, &in_bytes);
if (result != 0)
{
logError("file: "__FILE__", line: %d, "
"fdfs_recv_response fail, result: %d",
__LINE__, result);
}
}
if (result != 0)
{
break;
}
if (in_bytes < 2 * sizeof(int))
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d, recv data length: %d "\
"is invalid", __LINE__,
pTrackerServer->ip_addr, \
pTrackerServer->port, (int)in_bytes);
result = EINVAL;
break;
}
total_count = buff2int(response);
current_count = buff2int(response + sizeof(int));
if (total_count <= start_index)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d, total storage " \
"count: %d is invalid, which <= start " \
"index: %d", __LINE__, pTrackerServer->ip_addr,\
pTrackerServer->port, total_count, start_index);
result = EINVAL;
break;
}
if (current_count <= 0)
{
logError("file: "__FILE__", line: %d, " \
"tracker server %s:%d, current storage " \
"count: %d is invalid, which <= 0", \
__LINE__, pTrackerServer->ip_addr,\
pTrackerServer->port, current_count);
result = EINVAL;
break;
}
data_list[list_count].buffer = response;
data_list[list_count].content = response + 2 * sizeof(int);
data_list[list_count].length = in_bytes - 2 * sizeof(int);
list_count++;
/*
//logInfo("list_count: %d, total_count: %d, current_count: %d",
list_count, total_count, current_count);
*/
start_index += current_count;
if (start_index >= total_count)
{
break;
}
if (list_count == MAX_REQUEST_LOOP)
{
logError("file: "__FILE__", line: %d, " \
"response data from tracker " \
"server %s:%d is too large", \
__LINE__, pTrackerServer->ip_addr,\
pTrackerServer->port);
result = ENOSPC;
break;
}
}
tracker_disconnect_server_ex(conn, result != 0);
if (result == 0)
{
do
{
int total_length;
char *content;
total_length = 0;
for (i=0; i<list_count; i++)
{
total_length += data_list[i].length;
}
content = (char *)malloc(total_length + 1);
if (content == NULL)
{
result = errno != 0 ? errno : ENOMEM;
logError("file: "__FILE__", line: %d, " \
"malloc %d bytes fail, " \
"errno: %d, error info: %s", \
__LINE__, total_length + 1, \
result, STRERROR(result));
break;
}
p = content;
for (i=0; i<list_count; i++)
{
memcpy(p, data_list[i].content, data_list[i].length);
p += data_list[i].length;
}
*p = '\0';
//logInfo("list_count: %d, storage ids:\n%s", list_count, content);
result = fdfs_load_storage_ids(content, \
"storage-ids-from-tracker");
free(content);
} while (0);
}
for (i=0; i<list_count; i++)
{
free(data_list[i].buffer);
}
return result;
}
int trunk_file_do_lstat_func_ex(const FDFSStorePaths *pStorePaths, \
const int store_path_index, const char *true_filename, \
const int filename_len, const int stat_func, \
struct stat *pStat, FDFSTrunkFullInfo *pTrunkInfo, \
FDFSTrunkHeader *pTrunkHeader, int *pfd)
{
char full_filename[MAX_PATH_SIZE];
char buff[128];
char pack_buff[FDFS_TRUNK_FILE_HEADER_SIZE];
int64_t file_size;
int buff_len;
int fd;
int read_bytes;
int result;
pTrunkInfo->file.id = 0;
if (filename_len != FDFS_TRUNK_FILENAME_LENGTH) //not trunk file
{
snprintf(full_filename, sizeof(full_filename), "%s/data/%s", \
pStorePaths->paths[store_path_index], true_filename);
if (stat_func == FDFS_STAT_FUNC_STAT)
{
result = stat(full_filename, pStat);
}
else
{
result = lstat(full_filename, pStat);
}
if (result == 0)
{
return 0;
}
else
{
return errno != 0 ? errno : ENOENT;
}
}
memset(buff, 0, sizeof(buff));
base64_decode_auto(&g_fdfs_base64_context, (char *)true_filename + \
FDFS_TRUE_FILE_PATH_LEN, FDFS_FILENAME_BASE64_LENGTH, \
buff, &buff_len);
file_size = buff2long(buff + sizeof(int) * 2);
if (!IS_TRUNK_FILE(file_size)) //slave file
{
snprintf(full_filename, sizeof(full_filename), "%s/data/%s", \
pStorePaths->paths[store_path_index], true_filename);
if (stat_func == FDFS_STAT_FUNC_STAT)
{
result = stat(full_filename, pStat);
}
else
{
result = lstat(full_filename, pStat);
}
if (result == 0)
{
return 0;
}
else
{
return errno != 0 ? errno : ENOENT;
}
}
trunk_file_info_decode(true_filename + FDFS_TRUE_FILE_PATH_LEN + \
FDFS_FILENAME_BASE64_LENGTH, &pTrunkInfo->file);
pTrunkHeader->file_size = FDFS_TRUNK_FILE_TRUE_SIZE(file_size);
pTrunkHeader->mtime = buff2int(buff + sizeof(int));
pTrunkHeader->crc32 = buff2int(buff + sizeof(int) * 4);
memcpy(pTrunkHeader->formatted_ext_name, true_filename + \
(filename_len - (FDFS_FILE_EXT_NAME_MAX_LEN + 1)), \
FDFS_FILE_EXT_NAME_MAX_LEN + 2); //include tailing '\0'
pTrunkHeader->alloc_size = pTrunkInfo->file.size;
pTrunkInfo->path.store_path_index = store_path_index;
pTrunkInfo->path.sub_path_high = strtol(true_filename, NULL, 16);
pTrunkInfo->path.sub_path_low = strtol(true_filename + 3, NULL, 16);
trunk_get_full_filename_ex(pStorePaths, pTrunkInfo, full_filename, \
sizeof(full_filename));
fd = open(full_filename, O_RDONLY);
if (fd < 0)
{
return errno != 0 ? errno : EIO;
}
if (lseek(fd, pTrunkInfo->file.offset, SEEK_SET) < 0)
{
result = errno != 0 ? errno : EIO;
close(fd);
return result;
}
read_bytes = read(fd, buff, FDFS_TRUNK_FILE_HEADER_SIZE);
if (read_bytes == FDFS_TRUNK_FILE_HEADER_SIZE)
{
result = 0;
}
else
{
result = errno;
close(fd);
return result != 0 ? result : EINVAL;
}
memset(pStat, 0, sizeof(struct stat));
pTrunkHeader->file_type = *(buff + FDFS_TRUNK_FILE_FILE_TYPE_OFFSET);
if (pTrunkHeader->file_type == FDFS_TRUNK_FILE_TYPE_REGULAR)
{
pStat->st_mode = S_IFREG;
}
else if (pTrunkHeader->file_type == FDFS_TRUNK_FILE_TYPE_LINK)
{
pStat->st_mode = S_IFLNK;
}
else if (pTrunkHeader->file_type == FDFS_TRUNK_FILE_TYPE_NONE)
{
close(fd);
return ENOENT;
}
else
{
close(fd);
logError("file: "__FILE__", line: %d, " \
"Invalid file type: %d", __LINE__, \
pTrunkHeader->file_type);
return ENOENT;
}
trunk_pack_header(pTrunkHeader, pack_buff);
/*
{
char temp[265];
char szHexBuff[2 * FDFS_TRUNK_FILE_HEADER_SIZE + 1];
FDFSTrunkHeader trueTrunkHeader;
fprintf(stderr, "file: "__FILE__", line: %d, true buff=%s\n", __LINE__, \
bin2hex(buff+1, FDFS_TRUNK_FILE_HEADER_SIZE - 1, szHexBuff));
trunk_unpack_header(buff, &trueTrunkHeader);
fprintf(stderr, "file: "__FILE__", line: %d, true fields=%s\n", __LINE__, \
trunk_header_dump(&trueTrunkHeader, full_filename, sizeof(full_filename)));
fprintf(stderr, "file: "__FILE__", line: %d, my buff=%s\n", __LINE__, \
bin2hex(pack_buff+1, FDFS_TRUNK_FILE_HEADER_SIZE - 1, szHexBuff));
fprintf(stderr, "file: "__FILE__", line: %d, my trunk=%s, my fields=%s\n", __LINE__, \
trunk_info_dump(pTrunkInfo, temp, sizeof(temp)), \
trunk_header_dump(pTrunkHeader, full_filename, sizeof(full_filename)));
}
*/
if (memcmp(pack_buff, buff, FDFS_TRUNK_FILE_HEADER_SIZE) != 0)
{
close(fd);
return ENOENT;
}
pStat->st_size = pTrunkHeader->file_size;
pStat->st_mtime = pTrunkHeader->mtime;
if (pfd != NULL)
{
*pfd = fd;
}
else
{
close(fd);
}
return 0;
}
UINT32 TrackerMgr::GetStorageStat(ConnectionInfo *pTrackerServer,
TCHAR *pszGroupName, FDFSStorageStat *pStat, UINT32 nLen,
UINT32 *pnStatCount)
{
UINT32 nRet;
UINT64 nInBytes;
StorageStat rawStat[FDFS_MAX_GROUPS];
BYTE byOut[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN];
memset(byOut, 0, sizeof(byOut));
memset(pStat, 0, sizeof(FDFSStorageStat) * nLen);
UINT32 nNameLen = strlen(pszGroupName);
if (nNameLen > FDFS_GROUP_NAME_MAX_LEN)
{
nNameLen = FDFS_GROUP_NAME_MAX_LEN;
}
TrackerHeader *pHeader = (TrackerHeader*)byOut;
pHeader->byCmd = TRACKER_PROTO_CMD_SERVER_LIST_STORAGE;
memcpy(byOut + sizeof(TrackerHeader), pszGroupName, nNameLen);
long642buff(FDFS_GROUP_NAME_MAX_LEN, (char*)pHeader->byPkgLen);
EnterCriticalSection(&pTrackerServer->csSend);
if ((nRet = tcpsenddata_nb(pTrackerServer->sock, byOut, sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN, DEFAULT_NETWORK_TIMEOUT)) != 0)
{
closesocket(pTrackerServer->sock);
pTrackerServer->sock = INVALID_SOCKET;
LeaveCriticalSection(&pTrackerServer->csSend);
WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetStorageStat tcpsenddata_nb Header Failed, Error Code:%d"), nRet);
return enumNetworkError_FDFS;
}
TrackerHeader resp;
int nCount = 0;
EnterCriticalSection(&pTrackerServer->csRecv);
if ((nRet = tcprecvdata_nb(pTrackerServer->sock, &resp, sizeof(resp), DEFAULT_NETWORK_TIMEOUT, &nCount)) != 0)
{
closesocket(pTrackerServer->sock);
pTrackerServer->sock = INVALID_SOCKET;
LeaveCriticalSection(&pTrackerServer->csRecv);
LeaveCriticalSection(&pTrackerServer->csSend);
WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetStorageStat tcprecvdata_nb Header Failed, Error Code:%d"), nRet);
return enumNetworkError_FDFS;
}
if (resp.byStatus != 0)
{
closesocket(pTrackerServer->sock);
pTrackerServer->sock = INVALID_SOCKET;
LeaveCriticalSection(&pTrackerServer->csRecv);
LeaveCriticalSection(&pTrackerServer->csSend);
WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetStorageStat Status Error, %d"), resp.byStatus);
return enumFailure_FDFS;
}
nInBytes = buff2long64((const char*)(resp.byPkgLen));
if (nInBytes < 0 || (nInBytes % sizeof(StorageStat)) != 0 || (nInBytes / sizeof(StorageStat)) > FDFS_MAX_SERVERS_EACH_GROUP)
{
closesocket(pTrackerServer->sock);
pTrackerServer->sock = INVALID_SOCKET;
LeaveCriticalSection(&pTrackerServer->csRecv);
LeaveCriticalSection(&pTrackerServer->csSend);
WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetStorageStat Packet Len Error"));
return enumFailure_FDFS;
}
*pnStatCount = nInBytes / sizeof(StorageStat);
//包头接收完毕，接收Body
if ((nRet = tcprecvdata_nb(pTrackerServer->sock, rawStat, nInBytes, DEFAULT_NETWORK_TIMEOUT, &nCount)) != 0)
{
closesocket(pTrackerServer->sock);
pTrackerServer->sock = INVALID_SOCKET;
LeaveCriticalSection(&pTrackerServer->csRecv);
LeaveCriticalSection(&pTrackerServer->csSend);
WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetStorageStat tcprecvdata_nb Body Failed, Error Code:%d"), nRet);
return enumNetworkError_FDFS;
}
LeaveCriticalSection(&pTrackerServer->csRecv);
LeaveCriticalSection(&pTrackerServer->csSend);
//数据接收完毕，开始处理
if(nLen < *pnStatCount)
{
WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetStorageStat Storages Is Too Many"));
return enumFailure_FDFS;
}
StorageStatBuff *pStatBuff = NULL;
StorageStat *pSrc = NULL;
FDFSStorageInfo *pStorageInfo = NULL;
FDFSStorageStat *pDest = NULL;
for(int i = 0; i < *pnStatCount; i++)
{
pDest = &pStat[i];
pSrc = &rawStat[i];
pStatBuff = &(pSrc->statBuff);
pStorageInfo = &(pDest->stat);
pDest->byStatus = pSrc->byStatus;
//保留最后一个\0
memcpy(pDest->szID, pSrc->byID, FDFS_STORAGE_ID_MAX_SIZE - 1);
memcpy(pDest->szIpAddr, pSrc->byIP, IP_ADDRESS_SIZE - 1);
memcpy(pDest->szSrcId, pSrc->bySrcID, FDFS_STORAGE_ID_MAX_SIZE - 1);
strcpy(pDest->szDomainName, (const char*)pSrc->byDomainName);
strcpy(pDest->szVersion, (const char*)pSrc->byVersion);
pDest->joinTime = buff2long64((const char*)pSrc->byJoinTime);
pDest->upTime = buff2long64((const char*)pSrc->byUpTime);
pDest->nTotalMb = buff2long64((const char*)pSrc->byTotalMB);
pDest->nFreeMb = buff2long64((const char*)pSrc->byFreeMB);
pDest->nUploadPriority = buff2long64((const char*)pSrc->byUploadPriority);
pDest->nStorePathCount = buff2long64((const char*)pSrc->byStorePathCount);
pDest->nSubdirCountPerPath = buff2long64((const char*)pSrc->bySubdirCountPerPath);
pDest->nStoragePort = buff2long64((const char*)pSrc->byStoragePort);
pDest->nStorageHttpPort = buff2long64((const char*)pSrc->byStorageHttpPort);
pDest->nCurrentWritePath = buff2long64((const char*)pSrc->byCurrentWritePath);
pStorageInfo->connection.nAllocCount = buff2int((const char*)pStatBuff->connection.byAllocCount);
pStorageInfo->connection.nCurrentCount = buff2int((const char*)pStatBuff->connection.byCurrentCount);
pStorageInfo->connection.nMaxCount = buff2int((const char*)pStatBuff->connection.byMaxCount);
pStorageInfo->nTotalUploadCount = buff2long64((const char*)pStatBuff->byTotalUploadCount);
pStorageInfo->nSuccessUploadCount = buff2long64((const char*)pStatBuff->bySuccessUploadCount);
pStorageInfo->nTotalAppendCount = buff2long64((const char*)pStatBuff->byTotalAppendCount);
pStorageInfo->nSuccessAppendCount = buff2long64((const char*)pStatBuff->bySuccessAppendCount);
pStorageInfo->nTotalModifyCount = buff2long64((const char*)pStatBuff->byTotalModifyCount);
pStorageInfo->nSuccessModifyCount = buff2long64((const char*)pStatBuff->bySuccessModifyCount);
pStorageInfo->nTotalTruncateCount = buff2long64((const char*)pStatBuff->byTotalTruncateCount);
pStorageInfo->nSuccessTruncateCount = buff2long64((const char*)pStatBuff->bySuccessTruncateCount);
pStorageInfo->nTotalSetMetaCount = buff2long64((const char*)pStatBuff->byTotalSetMetaCount);
pStorageInfo->nSuccessSetMetaCount = buff2long64((const char*)pStatBuff->bySuccessSetMetaCount);
pStorageInfo->nTotalDeleteCount = buff2long64((const char*)pStatBuff->byTotalDeleteCount);
pStorageInfo->nSuccessDeleteCount = buff2long64((const char*)pStatBuff->bySuccessDeleteCount);
pStorageInfo->nTotalDownloadCount = buff2long64((const char*)pStatBuff->byTotalDownloadCount);
pStorageInfo->nSuccessDownloadCount = buff2long64((const char*)pStatBuff->bySuccessDownloadCount);
pStorageInfo->nTotalGetMetaCount = buff2long64((const char*)pStatBuff->byTotalGetMetaCount);
pStorageInfo->nSuccessGetMetaCount = buff2long64((const char*)pStatBuff->bySuccessGetMetaCount);
pStorageInfo->lastSourceUpdate = buff2long64((const char*)pStatBuff->byLastSourceUpdate);
pStorageInfo->lastSyncUpdate = buff2long64((const char*)pStatBuff->byLastSyncUpdate);
pStorageInfo->lastSyncedTimestamp = buff2long64((const char*)pStatBuff->byLastSyncedTimestamp);
pStorageInfo->nTotalCreateLinkCount = buff2long64((const char*)pStatBuff->byTotalCreateLinkCount);
pStorageInfo->nSuccessCreateLinkCount = buff2long64((const char*)pStatBuff->bySuccessCreateLinkCount);
pStorageInfo->nTotalDeleteLinkCount = buff2long64((const char*)pStatBuff->byTotalDeleteLinkCount);
pStorageInfo->nSuccessDeleteLinkCount = buff2long64((const char*)pStatBuff->bySuccessDeleteLinkCount);
pStorageInfo->nTotalUploadBytes = buff2long64((const char*)pStatBuff->byTotalUploadBytes);
pStorageInfo->nSuccessUploadBytes = buff2long64((const char*)pStatBuff->bySuccessUploadBytes);
pStorageInfo->nTotalAppendBytes = buff2long64((const char*)pStatBuff->byTotalAppendBytes);
pStorageInfo->nSuccessAppendBytes = buff2long64((const char*)pStatBuff->bySuccessAppendBytes);
pStorageInfo->nTotalModifyBytes = buff2long64((const char*)pStatBuff->byTotalModifyBytes);
pStorageInfo->nSuccessModifyBytes = buff2long64((const char*)pStatBuff->bySuccessModifyBytes);
pStorageInfo->nTotalDownloadBytes = buff2long64((const char*)pStatBuff->byTotalDownloadBytes);
pStorageInfo->nSuccessDownloadBytes = buff2long64((const char*)pStatBuff->bySuccessDownloadBytes);
pStorageInfo->nTotalSyncInBytes = buff2long64((const char*)pStatBuff->byTotalSyncInBytes);
pStorageInfo->nSuccessSyncInBytes = buff2long64((const char*)pStatBuff->bySuccessSyncInBytes);
pStorageInfo->nTotalSyncOutBytes = buff2long64((const char*)pStatBuff->byTotalSyncOutBytes);
pStorageInfo->nSuccessSyncOutBytes = buff2long64((const char*)pStatBuff->bySuccessSyncOutBytes);
pStorageInfo->nTotalFileOpenCount = buff2long64((const char*)pStatBuff->byTotalFileOpenCount);
pStorageInfo->nSuccessFileOpenCount = buff2long64((const char*)pStatBuff->bySuccessFileOpenCount);
pStorageInfo->nTotalFileReadCount = buff2long64((const char*)pStatBuff->byTotalFileReadCount);
pStorageInfo->nSuccessFileReadCount = buff2long64((const char*)pStatBuff->bySuccessFileReadCount);
pStorageInfo->nTotalFileWriteCount = buff2long64((const char*)pStatBuff->byTotalFileWriteCount);
pStorageInfo->nSuccessFileWriteCount = buff2long64((const char*)pStatBuff->bySuccessFileWriteCount);
pStorageInfo->lastHeartBeatTime = buff2long64((const char*)pStatBuff->byLastHeartBeatTime);
pDest->bIfTrunkServer = pSrc->byIfTrunkServer;
}
return enumSuccess_FDFS;
}
