pdxx
/
fastdfs
mirror of https://github.com/happyfish100/fastdfs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

adapt to libfastcommon 1.70 and libserverframe 1.2.0

use_libfastcommon1.70
YuQing 2023-10-12 17:55:11 +08:00
parent 4b42ed9fe2
commit e7caa614cf
9 changed files with 542 additions and 533 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
HISTORY
View File

@ -1,11 +1,13 @@
Version 6.10.0 2023-09-07
* use libfastcommon V1.70 and libserverframe 1.2.0
Version 6.9.5 2023-06-05
* fix possible out-of-bounds issues with array access
* fix realloc mistakes to avoid memory leaks
* add ExecStartPost=/bin/sleep 0.1 to systemd service files
* fdht_client/fdht_func.c: fixed compile error
Version 6.9.4 2023-02-15
* use epoll edge trigger to resolve github issues #608
* bugfixed: report connections' current_count and max_count correctly

20
storage/storage_dio.c
View File

@ -250,7 +250,7 @@ int dio_discard_file(struct fast_task_info *pTask)
StorageFileContext *pFileContext;
pFileContext = &(((StorageClientInfo *)pTask->arg)->file_context);
pFileContext->offset += pTask->length - pFileContext->buff_offset;
pFileContext->offset += pTask->recv.ptr->length - pFileContext->buff_offset;
if (pFileContext->offset >= pFileContext->end)
{
pFileContext->done_callback(pTask, 0);
@ -331,16 +331,16 @@ int dio_read_file(struct fast_task_info *pTask)
}
remain_bytes = pFileContext->end - pFileContext->offset;
capacity_bytes = pTask->size - pTask->length;
capacity_bytes = pTask->send.ptr->size - pTask->send.ptr->length;
read_bytes = (capacity_bytes < remain_bytes) ? \
capacity_bytes : remain_bytes;
/*
logInfo("###before dio read bytes: %d, pTask->length=%d, file offset=%ld", \
read_bytes, pTask->length, pFileContext->offset);
read_bytes, pTask->send.ptr->length, pFileContext->offset);
*/
if (fc_safe_read(pFileContext->fd, pTask->data + pTask->length, \
if (fc_safe_read(pFileContext->fd, pTask->send.ptr->data + pTask->send.ptr->length, \
read_bytes) != read_bytes)
{
result = errno != 0 ? errno : EIO;
@ -364,17 +364,17 @@ int dio_read_file(struct fast_task_info *pTask)
if (pFileContext->calc_crc32)
{
pFileContext->crc32 = CRC32_ex(pTask->data + pTask->length,
pFileContext->crc32 = CRC32_ex(pTask->send.ptr->data + pTask->send.ptr->length,
read_bytes, pFileContext->crc32);
}
pTask->length += read_bytes;
pTask->send.ptr->length += read_bytes;
pFileContext->offset += read_bytes;
/*
logInfo("###after dio read bytes: %d, pTask->length=%d, "
"file offset=%"PRId64", file size: %"PRId64, read_bytes,
pTask->length, pFileContext->offset, pFileContext->end);
pTask->send.ptr->length, pFileContext->offset, pFileContext->end);
*/
if (pFileContext->offset < pFileContext->end)
@ -441,8 +441,8 @@ int dio_write_file(struct fast_task_info *pTask)
}
}
pDataBuff = pTask->data + pFileContext->buff_offset;
write_bytes = pTask->length - pFileContext->buff_offset;
pDataBuff = pTask->recv.ptr->data + pFileContext->buff_offset;
write_bytes = pTask->recv.ptr->length - pFileContext->buff_offset;
if (fc_safe_write(pFileContext->fd, pDataBuff, write_bytes) != write_bytes)
{
result = errno != 0 ? errno : EIO;
@ -488,7 +488,7 @@ int dio_write_file(struct fast_task_info *pTask)
/*
logInfo("###dio fd: %d, write bytes: %d, pTask->length=%d, "
"buff_offset=%d", pFileContext->fd, write_bytes,
pTask->length, pFileContext->buff_offset);
pTask->recv.ptr->length, pFileContext->buff_offset);
*/
pFileContext->offset += write_bytes;

2
storage/storage_dump.c
View File

@ -365,7 +365,7 @@ static int fdfs_dump_storage_stat(char *buff, const int buffSize)
"last_synced_timestamp=%s\n"
"last_heart_beat_time=%s\n",
g_stat_change_count, g_sync_change_count,
free_queue_alloc_connections(),
free_queue_alloc_connections(&g_sf_context.free_queue),
SF_G_CONN_CURRENT_COUNT,
SF_G_CONN_MAX_COUNT,
g_storage_stat.total_upload_count,

7
storage/storage_func.c
View File

@ -1403,6 +1403,7 @@ static int init_my_result_per_tracker()
int storage_func_init(const char *filename)
{
const int fixed_buffer_size = 0;
const int task_buffer_extra_size = 0;
const bool need_set_run_by = false;
char *pGroupName;
@ -1439,11 +1440,11 @@ int storage_func_init(const char *filename)
sf_set_current_time();
SF_SET_CONTEXT_INI_CONFIG_EX(config, filename, &iniContext,
NULL, FDFS_STORAGE_SERVER_DEF_PORT,
SF_SET_CONTEXT_INI_CONFIG_EX(config, fc_comm_type_sock, filename,
&iniContext, NULL, FDFS_STORAGE_SERVER_DEF_PORT,
FDFS_STORAGE_SERVER_DEF_PORT, DEFAULT_WORK_THREADS,
"buff_size");
if ((result=sf_load_config_ex("storaged", &config,
if ((result=sf_load_config_ex("storaged", &config, fixed_buffer_size,
task_buffer_extra_size, need_set_run_by)) != 0)
{
return result;

352
storage/storage_service.c
View File

@ -423,11 +423,11 @@ static void storage_sync_delete_file_done_callback( \
pClientInfo->total_length = sizeof(TrackerHeader);
pClientInfo->total_offset = 0;
pTask->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->data;
pTask->send.ptr->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = result;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(pClientInfo->total_length - sizeof(TrackerHeader), \
long2buff(pClientInfo->total_length - sizeof(TrackerHeader),
pHeader->pkg_len);
sf_nio_notify(pTask, SF_NIO_STAGE_SEND);
@ -463,8 +463,8 @@ static void storage_sync_truncate_file_done_callback( \
pClientInfo->total_length = sizeof(TrackerHeader);
pClientInfo->total_offset = 0;
pTask->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->data;
pTask->send.ptr->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = result;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(pClientInfo->total_length - sizeof(TrackerHeader), \
@ -569,8 +569,8 @@ static void storage_sync_copy_file_done_callback(struct fast_task_info *pTask, \
pClientInfo->total_length = sizeof(TrackerHeader);
pClientInfo->total_offset = 0;
pTask->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->data;
pTask->send.ptr->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = result;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(pClientInfo->total_length - sizeof(TrackerHeader), \
@ -645,8 +645,8 @@ static void storage_sync_modify_file_done_callback( \
pClientInfo->total_length = sizeof(TrackerHeader);
pClientInfo->total_offset = 0;
pTask->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->data;
pTask->send.ptr->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = result;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(pClientInfo->total_length - sizeof(TrackerHeader), \
@ -666,9 +666,9 @@ static void storage_get_metadata_done_callback(struct fast_task_info *pTask,
if (err_no != 0)
{
__sync_add_and_fetch(&g_storage_stat.total_get_meta_count, 1);
if (pTask->length == sizeof(TrackerHeader)) //never response
if (pTask->send.ptr->length == sizeof(TrackerHeader)) //never response
{
pHeader = (TrackerHeader *)pTask->data;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = err_no;
sf_nio_notify(pTask, SF_NIO_STAGE_SEND);
}
@ -703,9 +703,9 @@ static void storage_download_file_done_callback( \
__sync_add_and_fetch(&g_storage_stat.total_download_bytes,
pFileContext->offset - pFileContext->start);
if (pTask->length == sizeof(TrackerHeader)) //never response
if (pTask->send.ptr->length == sizeof(TrackerHeader)) //never response
{
pHeader = (TrackerHeader *)pTask->data;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = err_no;
sf_nio_notify(pTask, SF_NIO_STAGE_SEND);
}
@ -1078,8 +1078,8 @@ static void storage_delete_fdfs_file_done_callback( \
pClientInfo->total_length = sizeof(TrackerHeader);
pClientInfo->total_offset = 0;
pTask->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->data;
pTask->send.ptr->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = result;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(pClientInfo->total_length - sizeof(TrackerHeader), \
@ -1149,7 +1149,7 @@ static void storage_upload_file_done_callback(struct fast_task_info *pTask, \
filename_len = strlen(pFileContext->fname2log);
pClientInfo->total_length = sizeof(TrackerHeader) + \
FDFS_GROUP_NAME_MAX_LEN + filename_len;
p = pTask->data + sizeof(TrackerHeader);
p = pTask->send.ptr->data + sizeof(TrackerHeader);
memcpy(p, pFileContext->extra_info.upload.group_name, \
FDFS_GROUP_NAME_MAX_LEN);
p += FDFS_GROUP_NAME_MAX_LEN;
@ -1170,9 +1170,9 @@ static void storage_upload_file_done_callback(struct fast_task_info *pTask, \
STORAGE_ACCESS_LOG(pTask, ACCESS_LOG_ACTION_UPLOAD_FILE, result);
pClientInfo->total_offset = 0;
pTask->length = pClientInfo->total_length;
pTask->send.ptr->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->data;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = result;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(pClientInfo->total_length - sizeof(TrackerHeader), \
@ -1240,7 +1240,7 @@ static void storage_trunk_create_link_file_done_callback( \
filename_len = strlen(pFileContext->fname2log);
pClientInfo->total_length = sizeof(TrackerHeader) + \
FDFS_GROUP_NAME_MAX_LEN + filename_len;
p = pTask->data + sizeof(TrackerHeader);
p = pTask->send.ptr->data + sizeof(TrackerHeader);
memcpy(p, pFileContext->extra_info.upload.group_name, \
FDFS_GROUP_NAME_MAX_LEN);
p += FDFS_GROUP_NAME_MAX_LEN;
@ -1258,9 +1258,9 @@ static void storage_trunk_create_link_file_done_callback( \
if (pCreateLinkArg->need_response)
{
pClientInfo->total_offset = 0;
pTask->length = pClientInfo->total_length;
pTask->send.ptr->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->data;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = result;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(pClientInfo->total_length - sizeof(TrackerHeader), \
@ -1327,9 +1327,9 @@ static void storage_append_file_done_callback(struct fast_task_info *pTask, \
pClientInfo->total_length = sizeof(TrackerHeader);
pClientInfo->total_offset = 0;
pTask->length = pClientInfo->total_length;
pTask->send.ptr->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->data;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = result;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(0, pHeader->pkg_len);
@ -1396,9 +1396,9 @@ static void storage_modify_file_done_callback(struct fast_task_info *pTask, \
pClientInfo->total_length = sizeof(TrackerHeader);
pClientInfo->total_offset = 0;
pTask->length = pClientInfo->total_length;
pTask->send.ptr->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->data;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = result;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(0, pHeader->pkg_len);
@ -1459,9 +1459,9 @@ static void storage_do_truncate_file_done_callback(struct fast_task_info *pTask,
pClientInfo->total_length = sizeof(TrackerHeader);
pClientInfo->total_offset = 0;
pTask->length = pClientInfo->total_length;
pTask->send.ptr->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->data;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = result;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(0, pHeader->pkg_len);
@ -1513,8 +1513,8 @@ static void storage_set_metadata_done_callback( \
pClientInfo->total_length = sizeof(TrackerHeader);
pClientInfo->total_offset = 0;
pTask->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->data;
pTask->send.ptr->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = result;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(pClientInfo->total_length - sizeof(TrackerHeader), \
@ -1544,7 +1544,7 @@ int storage_set_body_length(struct fast_task_info *pTask)
if (pClientInfo->total_length == 0) //header
{
total_length = buff2long(((TrackerHeader *)
pTask->data)->pkg_len);
pTask->recv.ptr->data)->pkg_len);
if (total_length < 0)
{
logError("file: "__FILE__", line: %d, "
@ -1554,13 +1554,14 @@ int storage_set_body_length(struct fast_task_info *pTask)
}
pClientInfo->total_length = total_length + sizeof(TrackerHeader);
if (pClientInfo->total_length > pTask->size)
if (pClientInfo->total_length > pTask->recv.ptr->size)
{
pTask->length = pTask->size - sizeof(TrackerHeader);
pTask->recv.ptr->length = pTask->recv.ptr->size -
sizeof(TrackerHeader);
}
else
{
pTask->length = total_length;
pTask->recv.ptr->length = total_length;
}
}
@ -1595,8 +1596,8 @@ static int sock_send_done_callback(struct fast_task_info *pTask,
pClientInfo->total_offset += length;
if (pClientInfo->total_offset >= pClientInfo->total_length)
{
if (pClientInfo->total_length == sizeof(TrackerHeader)
&& ((TrackerHeader *)pTask->data)->status == EINVAL)
if (pClientInfo->total_length == sizeof(TrackerHeader) &&
((TrackerHeader *)pTask->send.ptr->data)->status == EINVAL)
{
logDebug("file: "__FILE__", line: %d, "
"close conn: #%d, client ip: %s",
@ -2424,16 +2425,16 @@ static int storage_nio_notify(struct fast_task_info *pTask, const int stage)
pClientInfo = (StorageClientInfo *)pTask->arg;
if (stage == SF_NIO_STAGE_RECV)
{
pTask->offset = 0;
pTask->recv.ptr->offset = 0;
remain_bytes = pClientInfo->total_length -
pClientInfo->total_offset;
if (remain_bytes > pTask->size)
if (remain_bytes > pTask->recv.ptr->size)
{
pTask->length = pTask->size;
pTask->recv.ptr->length = pTask->recv.ptr->size;
}
else
{
pTask->length = remain_bytes;
pTask->recv.ptr->length = remain_bytes;
}
}
@ -2443,7 +2444,7 @@ static int storage_nio_notify(struct fast_task_info *pTask, const int stage)
static int calc_crc32_continue_callback(struct fast_task_info *pTask,
const int stage)
{
pTask->length = 0;
pTask->send.ptr->length = 0;
return storage_dio_queue_push(pTask);
}
@ -2509,27 +2510,27 @@ static int storage_trunk_create_link(struct fast_task_info *pTask, \
return result;
}
pTask->length = pTask->size;
p = pTask->data + (pTask->length - sizeof(TrunkCreateLinkArg) \
- file_bytes);
if (p < pTask->data + sizeof(TrackerHeader))
pTask->send.ptr->length = pTask->send.ptr->size;
p = pTask->send.ptr->data + (pTask->send.ptr->length -
sizeof(TrunkCreateLinkArg) - file_bytes);
if (p < pTask->send.ptr->data + sizeof(TrackerHeader))
{
logError("file: "__FILE__", line: %d, " \
"task buffer size: %d is too small", \
__LINE__, pTask->size);
__LINE__, pTask->send.ptr->size);
return ENOSPC;
}
pCreateLinkArg = (TrunkCreateLinkArg *)p;
memcpy(&(pCreateLinkArg->src_file_info), pSourceFileInfo, \
memcpy(&(pCreateLinkArg->src_file_info), pSourceFileInfo,
sizeof(SourceFileInfo));
pCreateLinkArg->need_response = bNeedReponse;
pClientInfo->extra_arg = (void *)pCreateLinkArg;
p += sizeof(TrunkCreateLinkArg);
memcpy(p, src_filename, file_bytes);
storage_trunk_do_create_link(pTask, file_bytes, p - pTask->data, \
dio_check_trunk_file_when_upload, \
storage_trunk_do_create_link(pTask, file_bytes, p - pTask->send.ptr->data,
dio_check_trunk_file_when_upload,
storage_trunk_create_link_file_done_callback);
return TASK_STATUS_CONTINUE;
}
@ -2925,20 +2926,18 @@ static int storage_server_set_metadata(struct fast_task_info *pTask)
return EINVAL;
}
if (nInPackLen + sizeof(TrackerHeader) >= pTask->size)
{
logError("file: "__FILE__", line: %d, " \
"cmd=%d, client ip: %s, package size " \
"%"PRId64" is not correct, " \
"expect length < %d", \
__LINE__, STORAGE_PROTO_CMD_SET_METADATA, \
pTask->client_ip, nInPackLen, \
pTask->size - (int)sizeof(TrackerHeader));
if (pClientInfo->total_length >= pTask->recv.ptr->size)
{
logError("file: "__FILE__", line: %d, "
"cmd=%d, client ip: %s, package size "
"%"PRId64" is not correct, "
"expect length < %d", __LINE__,
STORAGE_PROTO_CMD_SET_METADATA, pTask->client_ip,
pClientInfo->total_length, pTask->recv.ptr->size);
return EINVAL;
}
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
filename_len = buff2long(p);
p += FDFS_PROTO_PKG_LEN_SIZE;
meta_bytes = buff2long(p);
@ -3069,7 +3068,7 @@ static int storage_server_report_server_id(struct fast_task_info *pTask)
return EINVAL;
}
storage_server_id = pTask->data + sizeof(TrackerHeader);
storage_server_id = pTask->recv.ptr->data + sizeof(TrackerHeader);
*(storage_server_id + (FDFS_STORAGE_ID_MAX_SIZE - 1)) = '\0';
if (*storage_server_id == '\0')
{
@ -3130,7 +3129,7 @@ static int storage_server_trunk_sync_binlog(struct fast_task_info *pTask)
return EINVAL;
}
binlog_buff = pTask->data + sizeof(TrackerHeader);
binlog_buff = pTask->send.ptr->data + sizeof(TrackerHeader);
return trunk_binlog_write_buffer(binlog_buff, nInPackLen);
}
@ -3139,7 +3138,7 @@ static int query_file_info_response(struct fast_task_info *pTask,
{
char *p;
p = pTask->data + sizeof(TrackerHeader);
p = pTask->send.ptr->data + sizeof(TrackerHeader);
long2buff(finfo->fsize, p);
p += FDFS_PROTO_PKG_LEN_SIZE;
long2buff(finfo->mtime, p);
@ -3174,7 +3173,7 @@ static int query_file_info_response(struct fast_task_info *pTask,
}
p += IP_ADDRESS_SIZE;
((StorageClientInfo *)pTask->arg)->total_length = p - pTask->data;
((StorageClientInfo *)pTask->arg)->total_length = p - pTask->send.ptr->data;
return 0;
}
@ -3205,12 +3204,12 @@ static void calc_crc32_done_callback_for_query_finfo(
fast_mblock_free_object(&finfo_for_crc32_allocator, crc32_file_info);
pClientInfo->total_offset = 0;
pTask->length = pClientInfo->total_length;
pTask->send.ptr->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->data;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = result;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(pTask->length - sizeof(TrackerHeader), pHeader->pkg_len);
long2buff(pTask->send.ptr->length - sizeof(TrackerHeader), pHeader->pkg_len);
STORAGE_ACCESS_LOG(pTask, ACCESS_LOG_ACTION_QUERY_FILE, result);
sf_nio_notify(pTask, SF_NIO_STAGE_SEND);
@ -3342,14 +3341,14 @@ static int storage_server_query_file_info(struct fast_task_info *pTask)
return EINVAL;
}
in_buff = pTask->data + sizeof(TrackerHeader);
in_buff = pTask->recv.ptr->data + sizeof(TrackerHeader);
filename = in_buff + FDFS_GROUP_NAME_MAX_LEN;
*(filename + filename_len) = '\0';
STORAGE_ACCESS_STRCPY_FNAME2LOG(filename, filename_len, \
pClientInfo);
bSilence = ((TrackerHeader *)pTask->data)->status != 0;
bSilence = ((TrackerHeader *)pTask->recv.ptr->data)->status != 0;
memcpy(group_name, in_buff, FDFS_GROUP_NAME_MAX_LEN);
*(group_name + FDFS_GROUP_NAME_MAX_LEN) = '\0';
if (strcmp(group_name, g_group_name) != 0)
@ -3551,7 +3550,7 @@ static int storage_server_trunk_alloc_space(struct fast_task_info *pTask)
return EINVAL;
}
in_buff = pTask->data + sizeof(TrackerHeader);
in_buff = pTask->recv.ptr->data + sizeof(TrackerHeader);
memcpy(group_name, in_buff, FDFS_GROUP_NAME_MAX_LEN);
*(group_name + FDFS_GROUP_NAME_MAX_LEN) = '\0';
if (strcmp(group_name, g_group_name) != 0)
@ -3588,7 +3587,7 @@ static int storage_server_trunk_alloc_space(struct fast_task_info *pTask)
return result;
}
pApplyBody = (FDFSTrunkInfoBuff *)(pTask->data+sizeof(TrackerHeader));
pApplyBody = (FDFSTrunkInfoBuff *)(pTask->send.ptr->data+sizeof(TrackerHeader));
pApplyBody->store_path_index = trunkInfo.path.store_path_index;
pApplyBody->sub_path_high = trunkInfo.path.sub_path_high;
pApplyBody->sub_path_low = trunkInfo.path.sub_path_low;
@ -3596,7 +3595,7 @@ static int storage_server_trunk_alloc_space(struct fast_task_info *pTask)
int2buff(trunkInfo.file.offset, pApplyBody->offset);
int2buff(trunkInfo.file.size, pApplyBody->size);
pClientInfo->total_length = sizeof(TrackerHeader) + \
pClientInfo->total_length = sizeof(TrackerHeader) +
sizeof(FDFSTrunkInfoBuff);
return 0;
}
@ -3616,7 +3615,7 @@ static int storage_server_trunk_get_binlog_size(struct fast_task_info *pTask)
struct stat file_stat;
int64_t nInPackLen;
pHeader = (TrackerHeader *)pTask->data;
pHeader = (TrackerHeader *)pTask->recv.ptr->data;
pClientInfo = (StorageClientInfo *)pTask->arg;
nInPackLen = pClientInfo->total_length - sizeof(TrackerHeader);
@ -3650,7 +3649,7 @@ static int storage_server_trunk_get_binlog_size(struct fast_task_info *pTask)
return errno != 0 ? errno : ENOENT;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->send.ptr->data + sizeof(TrackerHeader);
long2buff(file_stat.st_size, p);
pClientInfo->total_length = sizeof(TrackerHeader)
@ -3664,7 +3663,7 @@ static int storage_server_trunk_truncate_binlog_file(struct fast_task_info *pTas
TrackerHeader *pHeader;
int64_t nInPackLen;
pHeader = (TrackerHeader *)pTask->data;
pHeader = (TrackerHeader *)pTask->recv.ptr->data;
pClientInfo = (StorageClientInfo *)pTask->arg;
nInPackLen = pClientInfo->total_length - sizeof(TrackerHeader);
pClientInfo->total_length = sizeof (TrackerHeader);
@ -3706,7 +3705,7 @@ static int storage_server_trunk_delete_binlog_marks(struct fast_task_info *pTask
int64_t nInPackLen;
int result;
pHeader = (TrackerHeader *)pTask->data;
pHeader = (TrackerHeader *)pTask->recv.ptr->data;
pClientInfo = (StorageClientInfo *)pTask->arg;
nInPackLen = pClientInfo->total_length - sizeof(TrackerHeader);
pClientInfo->total_length = sizeof (TrackerHeader);
@ -3767,7 +3766,7 @@ static int storage_server_trunk_confirm_or_free(struct fast_task_info *pTask)
FDFSTrunkFullInfo trunkInfo;
int64_t nInPackLen;
pHeader = (TrackerHeader *)pTask->data;
pHeader = (TrackerHeader *)pTask->recv.ptr->data;
pClientInfo = (StorageClientInfo *)pTask->arg;
nInPackLen = pClientInfo->total_length - sizeof(TrackerHeader);
pClientInfo->total_length = sizeof(TrackerHeader);
@ -3785,7 +3784,7 @@ static int storage_server_trunk_confirm_or_free(struct fast_task_info *pTask)
return EINVAL;
}
in_buff = pTask->data + sizeof(TrackerHeader);
in_buff = pTask->recv.ptr->data + sizeof(TrackerHeader);
memcpy(group_name, in_buff, FDFS_GROUP_NAME_MAX_LEN);
*(group_name + FDFS_GROUP_NAME_MAX_LEN) = '\0';
if (strcmp(group_name, g_group_name) != 0)
@ -3862,7 +3861,7 @@ static int storage_server_fetch_one_path_binlog_dealer(
store_path_index = pFileContext->extra_info.upload.trunk_info.
path.store_path_index;
pBasePath = g_fdfs_store_paths.paths[store_path_index].path;
pOutBuff = pTask->data;
pOutBuff = pTask->send.ptr->data;
bLast = false;
sprintf(diskLogicPath, "%c"FDFS_STORAGE_DATA_DIR_FORMAT,
@ -4034,7 +4033,7 @@ static int storage_server_fetch_one_path_binlog_dealer(
paths[store_path_index].path_len + 6);
}
if (pTask->size - (pOutBuff - pTask->data) <
if (pTask->send.ptr->size - (pOutBuff - pTask->send.ptr->data) <
STORAGE_BINLOG_LINE_SIZE + FDFS_PROTO_PKG_LEN_SIZE)
{
break;
@ -4055,14 +4054,14 @@ static int storage_server_fetch_one_path_binlog_dealer(
return result;
}
pTask->length = pOutBuff - pTask->data;
pTask->send.ptr->length = pOutBuff - pTask->send.ptr->data;
if (bLast)
{
pkg_len = pClientInfo->total_offset + pTask->length -
pkg_len = pClientInfo->total_offset + pTask->send.ptr->length -
sizeof(TrackerHeader);
long2buff(pkg_len, pOutBuff);
pTask->length += FDFS_PROTO_PKG_LEN_SIZE;
pTask->send.ptr->length += FDFS_PROTO_PKG_LEN_SIZE;
pClientInfo->total_length = pkg_len + FDFS_PROTO_PKG_LEN_SIZE
+ STORAGE_LAST_AHEAD_BYTES;
}
@ -4151,8 +4150,8 @@ static int storage_server_do_fetch_one_path_binlog(
pClientInfo->total_length = INFINITE_FILE_SIZE +
sizeof(TrackerHeader);
pClientInfo->total_offset = 0;
pTask->length = sizeof(TrackerHeader);
pHeader = (TrackerHeader *)pTask->data;
pTask->send.ptr->length = sizeof(TrackerHeader);
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = 0;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(pClientInfo->total_length - sizeof(TrackerHeader),
@ -4189,7 +4188,7 @@ static int storage_server_fetch_one_path_binlog(struct fast_task_info *pTask)
return EINVAL;
}
in_buff = pTask->data + sizeof(TrackerHeader);
in_buff = pTask->recv.ptr->data + sizeof(TrackerHeader);
memcpy(group_name, in_buff, FDFS_GROUP_NAME_MAX_LEN);
*(group_name + FDFS_GROUP_NAME_MAX_LEN) = '\0';
if (strcmp(group_name, g_group_name) != 0)
@ -4255,7 +4254,7 @@ static int storage_upload_file(struct fast_task_info *pTask, bool bAppenderFile)
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
store_path_index = *p++;
if (store_path_index == -1)
@ -4404,9 +4403,9 @@ static int storage_upload_file(struct fast_task_info *pTask, bool bAppenderFile)
}
pFileContext->continue_callback = storage_nio_notify;
return storage_write_to_file(pTask, file_offset, file_bytes, \
p - pTask->data, dio_write_file, \
storage_upload_file_done_callback, \
return storage_write_to_file(pTask, file_offset, file_bytes,
p - pTask->recv.ptr->data, dio_write_file,
storage_upload_file_done_callback,
clean_func, store_path_index);
}
@ -4527,7 +4526,7 @@ static void calc_crc32_done_callback_for_regenerate(
pClientInfo = (StorageClientInfo *)pTask->arg;
pFileContext = &(pClientInfo->file_context);
crc32_file_info = (StorageFileInfoForCRC32 *)pClientInfo->extra_arg;
pHeader = (TrackerHeader *)pTask->data;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
if (err_no == 0)
{
@ -4587,7 +4586,7 @@ static void calc_crc32_done_callback_for_regenerate(
pClientInfo->total_length = sizeof(TrackerHeader) +
FDFS_GROUP_NAME_MAX_LEN + filename_len;
p = pTask->data + sizeof(TrackerHeader);
p = pTask->send.ptr->data + sizeof(TrackerHeader);
memcpy(p, g_group_name, FDFS_GROUP_NAME_MAX_LEN);
p += FDFS_GROUP_NAME_MAX_LEN;
memcpy(p, return_filename, filename_len);
@ -4615,11 +4614,11 @@ static void calc_crc32_done_callback_for_regenerate(
}
pClientInfo->total_offset = 0;
pTask->length = pClientInfo->total_length;
pTask->send.ptr->length = pClientInfo->total_length;
pHeader->status = result;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(pTask->length - sizeof(TrackerHeader), pHeader->pkg_len);
long2buff(pTask->send.ptr->length - sizeof(TrackerHeader), pHeader->pkg_len);
STORAGE_ACCESS_LOG(pTask, ACCESS_LOG_ACTION_RENAME_FILE, result);
sf_nio_notify(pTask, SF_NIO_STAGE_SEND);
@ -4657,7 +4656,7 @@ static int storage_server_regenerate_appender_filename(struct fast_task_info *pT
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
memcpy(appender_filename, p, appender_filename_len);
*(appender_filename + appender_filename_len) = '\0';
@ -4720,7 +4719,7 @@ static int storage_append_file(struct fast_task_info *pTask)
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
appender_filename_len = buff2long(p);
p += FDFS_PROTO_PKG_LEN_SIZE;
@ -4784,7 +4783,7 @@ static int storage_append_file(struct fast_task_info *pTask)
pFileContext->continue_callback = storage_nio_notify;
return storage_write_to_file(pTask, stat_buf.st_size, file_bytes,
p - pTask->data, dio_write_file,
p - pTask->recv.ptr->data, dio_write_file,
storage_append_file_done_callback,
dio_append_finish_clean_up, store_path_index);
}
@ -4827,7 +4826,7 @@ static int storage_modify_file(struct fast_task_info *pTask)
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
appender_filename_len = buff2long(p);
p += FDFS_PROTO_PKG_LEN_SIZE;
@ -4913,7 +4912,7 @@ static int storage_modify_file(struct fast_task_info *pTask)
pFileContext->continue_callback = storage_nio_notify;
return storage_write_to_file(pTask, file_offset, file_bytes,
p - pTask->data, dio_write_file,
p - pTask->recv.ptr->data, dio_write_file,
storage_modify_file_done_callback,
dio_modify_finish_clean_up, store_path_index);
}
@ -4956,7 +4955,7 @@ static int storage_do_truncate_file(struct fast_task_info *pTask)
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
appender_filename_len = buff2long(p);
p += FDFS_PROTO_PKG_LEN_SIZE;
@ -5142,7 +5141,7 @@ static int storage_upload_slave_file(struct fast_task_info *pTask)
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
master_filename_len = buff2long(p);
p += FDFS_PROTO_PKG_LEN_SIZE;
@ -5323,8 +5322,8 @@ static int storage_upload_slave_file(struct fast_task_info *pTask)
| g_extra_open_file_flags;
pFileContext->continue_callback = storage_nio_notify;
return storage_write_to_file(pTask, 0, file_bytes, p - pTask->data, \
dio_write_file, storage_upload_file_done_callback, \
return storage_write_to_file(pTask, 0, file_bytes, p - pTask->recv.
ptr->data, dio_write_file, storage_upload_file_done_callback,
dio_write_finish_clean_up, store_path_index);
}
@ -5372,7 +5371,7 @@ static int storage_sync_copy_file(struct fast_task_info *pTask, \
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
filename_len = buff2long(p);
p += FDFS_PROTO_PKG_LEN_SIZE;
@ -5412,7 +5411,7 @@ static int storage_sync_copy_file(struct fast_task_info *pTask, \
return EINVAL;
}
have_file_content = ((TrackerHeader *)pTask->data)->status == 0;
have_file_content = ((TrackerHeader *)pTask->recv.ptr->data)->status == 0;
if (have_file_content)
{
if (file_bytes != nInPackLen - (2*FDFS_PROTO_PKG_LEN_SIZE + \
@ -5632,9 +5631,9 @@ static int storage_sync_copy_file(struct fast_task_info *pTask, \
if (have_file_content)
{
return storage_write_to_file(pTask, file_offset, file_bytes, \
p - pTask->data, deal_func, \
storage_sync_copy_file_done_callback, \
return storage_write_to_file(pTask, file_offset, file_bytes,
p - pTask->recv.ptr->data, deal_func,
storage_sync_copy_file_done_callback,
clean_func, store_path_index);
}
else
@ -5687,7 +5686,7 @@ static int storage_sync_append_file(struct fast_task_info *pTask)
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
filename_len = buff2long(p);
p += FDFS_PROTO_PKG_LEN_SIZE;
@ -5859,9 +5858,9 @@ static int storage_sync_append_file(struct fast_task_info *pTask)
pFileContext->extra_info.upload.before_close_callback = NULL;
pFileContext->continue_callback = storage_nio_notify;
return storage_write_to_file(pTask, start_offset, append_bytes, \
p - pTask->data, deal_func, \
storage_sync_modify_file_done_callback, \
return storage_write_to_file(pTask, start_offset, append_bytes,
p - pTask->recv.ptr->data, deal_func,
storage_sync_modify_file_done_callback,
dio_append_finish_clean_up, store_path_index);
}
@ -5909,7 +5908,7 @@ static int storage_sync_modify_file(struct fast_task_info *pTask)
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
filename_len = buff2long(p);
p += FDFS_PROTO_PKG_LEN_SIZE;
@ -6054,9 +6053,9 @@ static int storage_sync_modify_file(struct fast_task_info *pTask)
pFileContext->extra_info.upload.before_close_callback = NULL;
pFileContext->continue_callback = storage_nio_notify;
return storage_write_to_file(pTask, start_offset, modify_bytes, \
p - pTask->data, deal_func, \
storage_sync_modify_file_done_callback, \
return storage_write_to_file(pTask, start_offset, modify_bytes,
p - pTask->recv.ptr->data, deal_func,
storage_sync_modify_file_done_callback,
dio_modify_finish_clean_up, store_path_index);
}
@ -6101,7 +6100,7 @@ static int storage_sync_truncate_file(struct fast_task_info *pTask)
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
filename_len = buff2long(p);
p += FDFS_PROTO_PKG_LEN_SIZE;
@ -6281,7 +6280,7 @@ static int storage_do_sync_link_file(struct fast_task_info *pTask)
do
{
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
dest_filename_len = buff2long(p);
p += FDFS_PROTO_PKG_LEN_SIZE;
@ -6402,19 +6401,20 @@ static int storage_do_sync_link_file(struct fast_task_info *pTask)
formatted_ext_name, \
destTrunkHeader.formatted_ext_name);
pTask->length = pTask->size;
p = pTask->data + (pTask->length - src_filename_len);
if (p < pTask->data + sizeof(TrackerHeader))
pTask->send.ptr->length = pTask->send.ptr->size;
p = pTask->send.ptr->data + (pTask->send.
ptr->length - src_filename_len);
if (p < pTask->send.ptr->data + sizeof(TrackerHeader))
{
logError("file: "__FILE__", line: %d, " \
"task buffer size: %d is too small", \
__LINE__, pTask->size);
__LINE__, pTask->send.ptr->size);
break;
}
memcpy(p, src_filename, src_filename_len);
result = storage_trunk_do_create_link(pTask, \
src_filename_len, p - pTask->data, \
src_filename_len, p - pTask->send.ptr->data, \
dio_check_trunk_file_when_sync, NULL);
if (result != 0)
{
@ -6466,8 +6466,8 @@ static int storage_do_sync_link_file(struct fast_task_info *pTask)
CHECK_AND_WRITE_TO_STAT_FILE1
pClientInfo->total_offset = 0;
pTask->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->data;
pTask->send.ptr->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = result;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(pClientInfo->total_length - sizeof(TrackerHeader), \
@ -6508,7 +6508,7 @@ static int storage_sync_link_file(struct fast_task_info *pTask)
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
dest_filename_len = buff2long(p);
p += FDFS_PROTO_PKG_LEN_SIZE;
@ -6609,7 +6609,7 @@ static int storage_sync_rename_file(struct fast_task_info *pTask)
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
dest_filename_len = buff2long(p);
p += FDFS_PROTO_PKG_LEN_SIZE;
@ -6742,19 +6742,18 @@ static int storage_server_get_metadata(struct fast_task_info *pTask)
return EINVAL;
}
if (nInPackLen >= pTask->size)
if (pClientInfo->total_length >= pTask->recv.ptr->size)
{
logError("file: "__FILE__", line: %d, " \
"cmd=%d, client ip: %s, package size " \
"%"PRId64" is too large, " \
"expect length should < %d", __LINE__, \
STORAGE_PROTO_CMD_GET_METADATA, \
pTask->client_ip, \
nInPackLen, pTask->size);
logError("file: "__FILE__", line: %d, "
"cmd=%d, client ip: %s, package size "
"%"PRId64" is too large, "
"expect length should < %d", __LINE__,
STORAGE_PROTO_CMD_GET_METADATA, pTask->client_ip,
pClientInfo->total_length, pTask->recv.ptr->size);
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
memcpy(group_name, p, FDFS_GROUP_NAME_MAX_LEN);
*(group_name + FDFS_GROUP_NAME_MAX_LEN) = '\0';
@ -6869,19 +6868,19 @@ static int storage_server_download_file(struct fast_task_info *pTask)
return EINVAL;
}
if (nInPackLen >= pTask->size)
if (pClientInfo->total_length >= pTask->recv.ptr->size)
{
logError("file: "__FILE__", line: %d, " \
"cmd=%d, client ip: %s, package size " \
"%"PRId64" is too large, " \
"expect length should < %d", __LINE__, \
STORAGE_PROTO_CMD_DOWNLOAD_FILE, \
pTask->client_ip, \
nInPackLen, pTask->size);
logError("file: "__FILE__", line: %d, "
"cmd=%d, client ip: %s, package size "
"%"PRId64" is too large, "
"expect length should < %d", __LINE__,
STORAGE_PROTO_CMD_DOWNLOAD_FILE,
pTask->client_ip, pClientInfo->total_length,
pTask->recv.ptr->size);
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
file_offset = buff2long(p);
p += FDFS_PROTO_PKG_LEN_SIZE;
@ -7058,9 +7057,9 @@ static int storage_read_from_file(struct fast_task_info *pTask, \
pTask, store_path_index, pFileContext->op);
pFileContext->done_callback = done_callback;
pTask->length = sizeof(TrackerHeader);
pTask->send.ptr->length = sizeof(TrackerHeader);
pHeader = (TrackerHeader *)pTask->data;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = 0;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(download_bytes, pHeader->pkg_len);
@ -7171,18 +7170,19 @@ static int storage_sync_delete_file(struct fast_task_info *pTask)
return EINVAL;
}
if (nInPackLen >= pTask->size)
if (pClientInfo->total_length >= pTask->recv.ptr->size)
{
logError("file: "__FILE__", line: %d, " \
"cmd=%d, client ip: %s, package size " \
"%"PRId64" is too large, " \
"expect length should < %d", __LINE__, \
STORAGE_PROTO_CMD_SYNC_DELETE_FILE, \
pTask->client_ip, nInPackLen, pTask->size);
logError("file: "__FILE__", line: %d, "
"cmd=%d, client ip: %s, package size "
"%"PRId64" is too large, "
"expect length should < %d", __LINE__,
STORAGE_PROTO_CMD_SYNC_DELETE_FILE,
pTask->client_ip, pClientInfo->total_length,
pTask->recv.ptr->size);
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
pFileContext->timestamp2log = buff2int(p);
p += 4;
memcpy(group_name, p, FDFS_GROUP_NAME_MAX_LEN);
@ -7297,18 +7297,19 @@ static int storage_server_delete_file(struct fast_task_info *pTask)
return EINVAL;
}
if (nInPackLen >= pTask->size)
if (pClientInfo->total_length >= pTask->recv.ptr->size)
{
logError("file: "__FILE__", line: %d, " \
"cmd=%d, client ip: %s, package size " \
"%"PRId64" is too large, " \
"expect length should < %d", __LINE__, \
STORAGE_PROTO_CMD_DELETE_FILE, \
pTask->client_ip, nInPackLen, pTask->size);
logError("file: "__FILE__", line: %d, "
"cmd=%d, client ip: %s, package size "
"%"PRId64" is too large, "
"expect length should < %d", __LINE__,
STORAGE_PROTO_CMD_DELETE_FILE,
pTask->client_ip, pClientInfo->total_length,
pTask->recv.ptr->size);
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
memcpy(group_name, p, FDFS_GROUP_NAME_MAX_LEN);
*(group_name + FDFS_GROUP_NAME_MAX_LEN) = '\0';
p += FDFS_GROUP_NAME_MAX_LEN;
@ -7722,7 +7723,7 @@ static int storage_do_create_link(struct fast_task_info *pTask)
break;
}
p = pTask->data + sizeof(TrackerHeader);
p = pTask->recv.ptr->data + sizeof(TrackerHeader);
master_filename_len = buff2long(p);
p += FDFS_PROTO_PKG_LEN_SIZE;
src_filename_len = buff2long(p);
@ -7858,14 +7859,14 @@ static int storage_do_create_link(struct fast_task_info *pTask)
if (result == 0)
{
pClientInfo->total_length += FDFS_GROUP_NAME_MAX_LEN + filename_len;
p = pTask->data + sizeof(TrackerHeader);
p = pTask->send.ptr->data + sizeof(TrackerHeader);
memcpy(p, g_group_name, FDFS_GROUP_NAME_MAX_LEN);
memcpy(p + FDFS_GROUP_NAME_MAX_LEN, filename, filename_len);
}
pClientInfo->total_offset = 0;
pTask->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->data;
pTask->send.ptr->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = result;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(pClientInfo->total_length - sizeof(TrackerHeader), \
@ -7907,7 +7908,7 @@ static int storage_create_link(struct fast_task_info *pTask)
return EINVAL;
}
p = pTask->data + sizeof(TrackerHeader) + FDFS_PROTO_PKG_LEN_SIZE;
p = pTask->recv.ptr->data + sizeof(TrackerHeader) + FDFS_PROTO_PKG_LEN_SIZE;
src_filename_len = buff2long(p);
if (src_filename_len <= 0 || src_filename_len >= \
sizeof(src_filename))
@ -7985,15 +7986,14 @@ static int storage_deal_task(struct fast_task_info *pTask, const int stage)
int result;
pClientInfo = (StorageClientInfo *)pTask->arg;
pHeader = (TrackerHeader *)pTask->data;
pHeader = (TrackerHeader *)pTask->recv.ptr->data;
if (pClientInfo->total_offset == 0)
{
pClientInfo->total_offset = pTask->length;
pClientInfo->total_offset = pTask->send.ptr->length;
}
else
{
pClientInfo->total_offset += pTask->length;
pClientInfo->total_offset += pTask->send.ptr->length;
/* continue write to file */
return storage_dio_queue_push(pTask);
@ -8164,12 +8164,12 @@ static int storage_deal_task(struct fast_task_info *pTask, const int stage)
{
pClientInfo->total_length = sizeof(TrackerHeader);
}
pTask->length = pClientInfo->total_length;
pTask->send.ptr->length = pClientInfo->total_length;
pHeader = (TrackerHeader *)pTask->data;
pHeader = (TrackerHeader *)pTask->send.ptr->data;
pHeader->status = result;
pHeader->cmd = STORAGE_PROTO_CMD_RESP;
long2buff(pClientInfo->total_length - sizeof(TrackerHeader), \
long2buff(pClientInfo->total_length - sizeof(TrackerHeader),
pHeader->pkg_len);
sf_send_add_event(pTask);
return result;

2
storage/tracker_client_thread.c
View File

@ -2314,7 +2314,7 @@ static int tracker_heart_beat(ConnectionInfo *pTrackerServer,
pStatBuff = (FDFSStorageStatBuff *)( \
out_buff + sizeof(TrackerHeader));
int2buff(free_queue_alloc_connections(),
int2buff(free_queue_alloc_connections(&g_sf_context.free_queue),
pStatBuff->connection.sz_alloc_count);
int2buff(SF_G_CONN_CURRENT_COUNT,
pStatBuff->connection.sz_current_count);

7
tracker/tracker_func.c
View File

@ -126,6 +126,7 @@ static int tracker_load_storage_id_info(const char *config_filename, \
int tracker_load_from_conf_file(const char *filename)
{
const int fixed_buffer_size = 0;
const int task_buffer_extra_size = 0;
const bool need_set_run_by = false;
char *pSlotMinSize;
@ -171,11 +172,11 @@ int tracker_load_from_conf_file(const char *filename)
sf_set_current_time();
SF_SET_CONTEXT_INI_CONFIG_EX(config, filename, &iniContext,
NULL, FDFS_TRACKER_SERVER_DEF_PORT,
SF_SET_CONTEXT_INI_CONFIG_EX(config, fc_comm_type_sock, filename,
&iniContext, NULL, FDFS_TRACKER_SERVER_DEF_PORT,
FDFS_TRACKER_SERVER_DEF_PORT, DEFAULT_WORK_THREADS,
"buff_size");
if ((result=sf_load_config_ex("trackerd", &config,
if ((result=sf_load_config_ex("trackerd", &config, fixed_buffer_size,
task_buffer_extra_size, need_set_run_by)) != 0)
{
return result;

9
tracker/tracker_proto.c
View File

@ -26,12 +26,13 @@
int fdfs_set_body_length(struct fast_task_info *pTask)
{
pTask->length = buff2long(((TrackerHeader *)pTask->data)->pkg_len);
if (pTask->length < 0)
pTask->recv.ptr->length = buff2long(((TrackerHeader *)
pTask->recv.ptr->data)->pkg_len);
if (pTask->recv.ptr->length < 0)
{
logError("file: "__FILE__", line: %d, "
"client ip: %s, pkg length: %d < 0",
__LINE__, pTask->client_ip, pTask->length);
"client ip: %s, pkg length: %d < 0", __LINE__,
pTask->client_ip, pTask->recv.ptr->length);
return EINVAL;
}

670
tracker/tracker_service.c
View File

File diff suppressed because it is too large Load Diff