adapt to libserverframe 1.2.5

fgrep: warning: fgrep is obsolescent; use grep -F

HISTORY

@@ -1,4 +1,22 @@
 
+Version 6.12.2  2024-09-16
+ * use libfastcommon V1.75 and libserverframe 1.2.5
+
+Version 6.12.1  2024-03-06
+ * adapt to libserverframe 1.2.3
+ * bugfixed: notify_leader_changed support IPv6 correctly
+ * log square quoted IPv6 address
+
+Version 6.12.0  2024-02-12
+ * bugfixed: parse ip and port use parseAddress instead of splitEx
+ * bugfixed: fdfs_server_info_to_string support IPv6 correctly
+ * check filename duplicate by hashtable instead of file system access
+
+Version 6.11.0  2023-12-10
+ * support IPv6, config item: address_family in tracker.conf and storage.conf
+   use libfastcommon V1.71 and libserverframe 1.2.1
+ * storage.conf can specify the storage server ID for NAT network
+
 Version 6.10.0  2023-09-07
  * use libfastcommon V1.70 and libserverframe 1.2.0
 

INSTALL

@@ -11,7 +11,7 @@ Chinese language: http://www.fastken.com/
 # command lines as:
 
    git clone https://github.com/happyfish100/libfastcommon.git
-   cd libfastcommon; git checkout V1.0.70
+   cd libfastcommon; git checkout V1.0.75
    ./make.sh clean && ./make.sh && ./make.sh install
 
 
@@ -21,7 +21,7 @@ Chinese language: http://www.fastken.com/
 # command lines as:
 
    git clone https://github.com/happyfish100/libserverframe.git
-   cd libserverframe; git checkout V1.2.0
+   cd libserverframe; git checkout V1.2.5
    ./make.sh clean && ./make.sh && ./make.sh install
 
 # step 3. download fastdfs source codes and install it, 
@@ -30,7 +30,7 @@ Chinese language: http://www.fastken.com/
 # command lines as:
 
    git clone https://github.com/happyfish100/fastdfs.git
-   cd fastdfs; git checkout V6.10.0
+   cd fastdfs; git checkout V6.12.2
    ./make.sh clean && ./make.sh && ./make.sh install
 
 

client/Makefile.in

@@ -68,8 +68,8 @@ install:
 	mkdir -p $(TARGET_LIB)
 	mkdir -p $(TARGET_PREFIX)/lib
 	cp -f $(ALL_PRGS) $(TARGET_PATH)
-	if [ $(ENABLE_STATIC_LIB) -eq 1 ]; then cp -f $(STATIC_LIBS) $(TARGET_LIB); cp -f $(STATIC_LIBS) $(TARGET_PREFIX)/lib/;fi
-	if [ $(ENABLE_SHARED_LIB) -eq 1 ]; then cp -f $(CLIENT_SHARED_LIBS) $(TARGET_LIB); cp -f $(CLIENT_SHARED_LIBS) $(TARGET_PREFIX)/lib/;fi
+	if [ $(ENABLE_STATIC_LIB) -eq 1 ]; then cp -f $(STATIC_LIBS) $(TARGET_LIB); cp -f $(STATIC_LIBS) $(TARGET_PREFIX)/lib/; fi
+	if [ $(ENABLE_SHARED_LIB) -eq 1 ]; then cp -f $(CLIENT_SHARED_LIBS) $(TARGET_LIB); cp -f $(CLIENT_SHARED_LIBS) $(TARGET_PREFIX)/lib/; fi
 
 	mkdir -p $(TARGET_INC)/fastdfs
 	cp -f $(FDFS_HEADER_FILES) $(TARGET_INC)/fastdfs

client/client_func.c

@@ -134,17 +134,18 @@ static int copy_tracker_servers(TrackerServerGroup *pTrackerGroup,
 		}
 	}
 
-	/*
+    /*
 	{
 	TrackerServerInfo *pServer;
-	for (pServer=pTrackerGroup->servers; pServer<pTrackerGroup->servers+ \
+    char formatted_ip[FORMATTED_IP_SIZE];
+	for (pServer=pTrackerGroup->servers; pServer<pTrackerGroup->servers+
 		pTrackerGroup->server_count;	pServer++)
 	{
-		//printf("server=%s:%u\n", \
-			pServer->ip_addr, pServer->port);
+        format_ip_address(pServer->connections[0].ip_addr, formatted_ip);
+		printf("server=%s:%u\n", formatted_ip, pServer->connections[0].port);
 	}
 	}
-	*/
+    */
 
 	return 0;
 }
@@ -241,7 +242,7 @@ static int fdfs_get_params_from_tracker(bool *use_storage_id)
 
 	continue_flag = false;
 	if ((result=fdfs_get_ini_context_from_tracker(&g_tracker_group,
-		&iniContext, &continue_flag, false, NULL)) != 0)
+                    &iniContext, &continue_flag)) != 0)
     {
         return result;
     }
@@ -348,39 +349,77 @@ static int fdfs_client_do_init_ex(TrackerServerGroup *pTrackerGroup, \
 		return result;
 	}
 
-	load_fdfs_parameters_from_tracker = iniGetBoolValue(NULL, \
-				"load_fdfs_parameters_from_tracker", \
+	load_fdfs_parameters_from_tracker = iniGetBoolValue(NULL,
+				"load_fdfs_parameters_from_tracker",
 				iniContext, false);
 	if (load_fdfs_parameters_from_tracker)
 	{
-		fdfs_get_params_from_tracker(&use_storage_id);
+		if ((result=fdfs_get_params_from_tracker(&use_storage_id)) != 0)
+        {
+            return result;
+        }
 	}
 	else
-	{
-		use_storage_id = iniGetBoolValue(NULL, "use_storage_id", \
-				iniContext, false);
-		if (use_storage_id)
-		{
-			result = fdfs_load_storage_ids_from_file( \
-					conf_filename, iniContext);
-		}
-	}
+    {
+        use_storage_id = iniGetBoolValue(NULL, "use_storage_id",
+                iniContext, false);
+        if (use_storage_id)
+        {
+            if ((result=fdfs_load_storage_ids_from_file(
+                            conf_filename, iniContext)) != 0)
+            {
+                return result;
+            }
+        }
+    }
+
+    if (use_storage_id)
+    {
+        FDFSStorageIdInfo *idInfo;
+        FDFSStorageIdInfo *end;
+        char *connect_first_by;
+
+        end = g_storage_ids_by_id.ids + g_storage_ids_by_id.count;
+        for (idInfo=g_storage_ids_by_id.ids; idInfo<end; idInfo++)
+        {
+            if (idInfo->ip_addrs.count > 1)
+            {
+                g_multi_storage_ips = true;
+                break;
+            }
+        }
+
+        if (g_multi_storage_ips)
+        {
+            connect_first_by = iniGetStrValue(NULL,
+                    "connect_first_by", iniContext);
+            if (connect_first_by != NULL && strncasecmp(connect_first_by,
+                        "last", 4) == 0)
+            {
+                g_connect_first_by = fdfs_connect_first_by_last_connected;
+            }
+        }
+    }
 
 #ifdef DEBUG_FLAG
-	logDebug("base_path=%s, " \
-		"connect_timeout=%d, "\
-		"network_timeout=%d, "\
-		"tracker_server_count=%d, " \
-		"anti_steal_token=%d, " \
-		"anti_steal_secret_key length=%d, " \
-		"use_connection_pool=%d, " \
-		"g_connection_pool_max_idle_time=%ds, " \
-		"use_storage_id=%d, storage server id count: %d\n", \
-		SF_G_BASE_PATH_STR, SF_G_CONNECT_TIMEOUT, \
-		SF_G_NETWORK_TIMEOUT, pTrackerGroup->server_count, \
-		g_anti_steal_token, g_anti_steal_secret_key.length, \
-		g_use_connection_pool, g_connection_pool_max_idle_time, \
-		use_storage_id, g_storage_ids_by_id.count);
+	logDebug("base_path=%s, "
+		"connect_timeout=%d, "
+		"network_timeout=%d, "
+		"tracker_server_count=%d, "
+		"anti_steal_token=%d, "
+		"anti_steal_secret_key length=%d, "
+		"use_connection_pool=%d, "
+		"g_connection_pool_max_idle_time=%ds, "
+		"use_storage_id=%d, connect_first_by=%s, "
+        "storage server id count: %d, "
+        "multi storage ips: %d\n",
+		SF_G_BASE_PATH_STR, SF_G_CONNECT_TIMEOUT,
+		SF_G_NETWORK_TIMEOUT, pTrackerGroup->server_count,
+		g_anti_steal_token, g_anti_steal_secret_key.length,
+		g_use_connection_pool, g_connection_pool_max_idle_time,
+		use_storage_id, g_connect_first_by == fdfs_connect_first_by_tracker ?
+        "tracker" : "last-connected", g_storage_ids_by_id.count,
+        g_multi_storage_ips);
 #endif
 
 	return 0;

client/client_global.c

@@ -13,5 +13,7 @@
 int g_tracker_server_http_port = 80;
 TrackerServerGroup g_tracker_group = {0, 0, -1, NULL};
 
+bool g_multi_storage_ips = false;
+FDFSConnectFirstBy g_connect_first_by = fdfs_connect_first_by_tracker;
 bool g_anti_steal_token = false;
 BufferInfo g_anti_steal_secret_key = {0};

client/client_global.h

@@ -15,6 +15,11 @@
 #include "tracker_types.h"
 #include "fdfs_shared_func.h"
 
+typedef enum {
+    fdfs_connect_first_by_tracker,
+    fdfs_connect_first_by_last_connected
+} FDFSConnectFirstBy;
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -22,6 +27,8 @@ extern "C" {
 extern int g_tracker_server_http_port;
 extern TrackerServerGroup g_tracker_group;
 
+extern bool g_multi_storage_ips;
+extern FDFSConnectFirstBy g_connect_first_by;
 extern bool g_anti_steal_token;
 extern BufferInfo g_anti_steal_secret_key;
 

client/fdfs_monitor.c

@@ -35,12 +35,13 @@ static void usage(char *argv[])
 
 int main(int argc, char *argv[])
 {
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char *conf_filename;
-	int result;
 	char *op_type;
+	char *group_name;
 	char *tracker_server;
 	int arg_index;
-	char *group_name;
+	int result;
 
 	if (argc < 2)
 	{
@@ -96,7 +97,7 @@ int main(int argc, char *argv[])
 	}
 
 	log_init();
-	g_log_context.log_level = LOG_DEBUG;
+	//g_log_context.log_level = LOG_DEBUG;
 	ignore_signal_pipe();
 
 	if ((result=fdfs_client_init(conf_filename)) != 0)
@@ -155,7 +156,9 @@ int main(int argc, char *argv[])
 		fdfs_client_destroy();
 		return errno != 0 ? errno : ECONNREFUSED;
 	}
-	printf("\ntracker server is %s:%u\n\n", pTrackerServer->ip_addr, pTrackerServer->port);
+    format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+	printf("\ntracker server is %s:%u\n\n", formatted_ip,
+            pTrackerServer->port);
 
 	if (arg_index < argc)
 	{

client/fdfs_test.c

@@ -66,6 +66,7 @@ int main(int argc, char *argv[])
 	int meta_count;
 	int i;
 	FDFSMetaData *pMetaList;
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char token[32 + 1];
 	char file_id[128];
 	char file_url[256];
@@ -73,7 +74,7 @@ int main(int argc, char *argv[])
 	char szPortPart[16];
 	int url_len;
 	time_t ts;
-        char *file_buff;
+    char *file_buff;
 	int64_t file_size;
 	char *operation;
 	char *meta_buff;
@@ -460,8 +461,9 @@ g_fdfs_version.patch);
 				printf("server list (%d):\n", server_count);
 				for (i=0; i<server_count; i++)
 				{
-					printf("\t%s:%u\n", \
-						storageServers[i].ip_addr, \
+                    format_ip_address(storageServers[i].
+                            ip_addr, formatted_ip);
+					printf("\t%s:%u\n", formatted_ip,
 						storageServers[i].port);
 				}
 				printf("\n");
@@ -488,8 +490,8 @@ g_fdfs_version.patch);
 			return result;
 		}
 
-		printf("storage=%s:%u\n", storageServer.ip_addr, \
-			storageServer.port);
+        format_ip_address(storageServer.ip_addr, formatted_ip);
+		printf("storage=%s:%u\n", formatted_ip, storageServer.port);
 
 		if ((pStorageServer=tracker_make_connection(&storageServer, \
 			&result)) == NULL)
@@ -670,15 +672,17 @@ g_fdfs_version.patch);
 	/* for test only */
 	if ((result=fdfs_active_test(pTrackerServer)) != 0)
 	{
-		printf("active_test to tracker server %s:%u fail, errno: %d\n", \
-			pTrackerServer->ip_addr, pTrackerServer->port, result);
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		printf("active_test to tracker server %s:%u fail, errno: %d\n",
+			formatted_ip, pTrackerServer->port, result);
 	}
 
 	/* for test only */
 	if ((result=fdfs_active_test(pStorageServer)) != 0)
 	{
-		printf("active_test to storage server %s:%u fail, errno: %d\n", \
-			pStorageServer->ip_addr, pStorageServer->port, result);
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		printf("active_test to storage server %s:%u fail, errno: %d\n",
+			formatted_ip, pStorageServer->port, result);
 	}
 
 	tracker_close_connection_ex(pStorageServer, true);
@@ -688,4 +692,3 @@ g_fdfs_version.patch);
 
 	return result;
 }
-

client/fdfs_test1.c

@@ -63,6 +63,7 @@ int main(int argc, char *argv[])
 	int meta_count;
 	int i;
 	FDFSMetaData *pMetaList;
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char token[32 + 1];
 	char file_id[128];
 	char master_file_id[128];
@@ -71,7 +72,7 @@ int main(int argc, char *argv[])
 	char szPortPart[16];
 	int url_len;
 	time_t ts;
-        char *file_buff;
+    char *file_buff;
 	int64_t file_size;
 	char *operation;
 	char *meta_buff;
@@ -432,8 +433,9 @@ g_fdfs_version.patch);
 				printf("server list (%d):\n", server_count);
 				for (i=0; i<server_count; i++)
 				{
-					printf("\t%s:%u\n", \
-						storageServers[i].ip_addr, \
+                    format_ip_address(storageServers[i].
+                            ip_addr, formatted_ip);
+					printf("\t%s:%u\n", formatted_ip,
 						storageServers[i].port);
 				}
 				printf("\n");
@@ -455,8 +457,8 @@ g_fdfs_version.patch);
 			return result;
 		}
 
-		printf("storage=%s:%u\n", storageServer.ip_addr, \
-			storageServer.port);
+        format_ip_address(storageServer.ip_addr, formatted_ip);
+		printf("storage=%s:%u\n", formatted_ip, storageServer.port);
 
 		if ((pStorageServer=tracker_make_connection(&storageServer, \
 			&result)) == NULL)
@@ -637,15 +639,17 @@ g_fdfs_version.patch);
 	/* for test only */
 	if ((result=fdfs_active_test(pTrackerServer)) != 0)
 	{
-		printf("active_test to tracker server %s:%u fail, errno: %d\n", \
-			pTrackerServer->ip_addr, pTrackerServer->port, result);
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		printf("active_test to tracker server %s:%u fail, errno: %d\n",
+			formatted_ip, pTrackerServer->port, result);
 	}
 
 	/* for test only */
 	if ((result=fdfs_active_test(pStorageServer)) != 0)
 	{
-		printf("active_test to storage server %s:%u fail, errno: %d\n", \
-			pStorageServer->ip_addr, pStorageServer->port, result);
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		printf("active_test to storage server %s:%u fail, errno: %d\n",
+			formatted_ip, pStorageServer->port, result);
 	}
 
 	tracker_close_connection_ex(pStorageServer, true);

client/storage_client.c

@@ -31,8 +31,7 @@
 #include "client_global.h"
 #include "fastcommon/base64.h"
 
-static struct base64_context the_base64_context;
-static int the_base64_context_inited = 0;
+static int g_base64_context_inited = 0;
 
 #define FDFS_SPLIT_GROUP_NAME_AND_FILENAME(file_id) \
 	char in_file_id[FDFS_GROUP_NAME_MAX_LEN + 128]; \
@@ -65,6 +64,103 @@ static int the_base64_context_inited = 0;
 		ppStorageServer, TRACKER_PROTO_CMD_SERVICE_QUERY_UPDATE, \
 		group_name, filename, pNewStorage, new_connection)
 
+static ConnectionInfo *make_connection_by_tracker(
+        ConnectionInfo *pStorageServer, int *err_no)
+{
+    ConnectionInfo *conn;
+    FDFSStorageIdInfo *idInfo;
+
+    if ((conn=tracker_make_connection(pStorageServer, err_no)) != NULL)
+    {
+        return conn;
+    }
+
+    if (!g_multi_storage_ips)
+    {
+        return NULL;
+    }
+
+    if ((idInfo=fdfs_get_storage_id_by_ip_port(pStorageServer->ip_addr,
+                    pStorageServer->port)) == NULL)
+    {
+        return NULL;
+    }
+
+    if (idInfo->ip_addrs.count < 2)
+    {
+        return NULL;
+    }
+
+    if (strcmp(pStorageServer->ip_addr, idInfo->ip_addrs.ips[0].address) == 0)
+    {
+        strcpy(pStorageServer->ip_addr, idInfo->ip_addrs.ips[1].address);
+    }
+    else
+    {
+        strcpy(pStorageServer->ip_addr, idInfo->ip_addrs.ips[0].address);
+    }
+    return tracker_make_connection(pStorageServer, err_no);
+}
+
+static ConnectionInfo *make_connection_by_last_connected(
+        ConnectionInfo *pStorageServer, int *err_no)
+{
+    ConnectionInfo *conn;
+    FDFSStorageIdInfo *idInfo;
+    int index;
+
+    if (!g_multi_storage_ips)
+    {
+        return tracker_make_connection(pStorageServer, err_no);
+    }
+
+    if ((idInfo=fdfs_get_storage_id_by_ip_port(pStorageServer->ip_addr,
+                    pStorageServer->port)) == NULL)
+    {
+        return tracker_make_connection(pStorageServer, err_no);
+    }
+    if (idInfo->ip_addrs.count < 2)
+    {
+        return tracker_make_connection(pStorageServer, err_no);
+    }
+
+    index = idInfo->ip_addrs.index;
+    if (strcmp(pStorageServer->ip_addr, idInfo->ip_addrs.
+                ips[index].address) != 0)
+    {
+        strcpy(pStorageServer->ip_addr, idInfo->ip_addrs.
+                ips[index].address);
+    }
+    if ((conn=tracker_make_connection(pStorageServer, err_no)) != NULL)
+    {
+        return conn;
+    }
+
+    if (++index == idInfo->ip_addrs.count)
+    {
+        index = 0;
+    }
+    strcpy(pStorageServer->ip_addr, idInfo->ip_addrs.ips[index].address);
+    if ((conn=tracker_make_connection(pStorageServer, err_no)) != NULL)
+    {
+        idInfo->ip_addrs.index = index;
+    }
+    return conn;
+}
+
+static inline ConnectionInfo *storage_make_connection(
+        ConnectionInfo *pStorageServer, int *err_no)
+{
+    if (g_connect_first_by == fdfs_connect_first_by_tracker)
+    {
+        return make_connection_by_tracker(pStorageServer, err_no);
+    }
+    else
+    {
+        return make_connection_by_last_connected(pStorageServer, err_no);
+    }
+}
+
 static int storage_get_connection(ConnectionInfo *pTrackerServer, \
 		ConnectionInfo **ppStorageServer, const byte cmd, \
 		const char *group_name, const char *filename, \
@@ -98,7 +194,7 @@ static int storage_get_connection(ConnectionInfo *pTrackerServer, \
 			return result;
 		}
 
-		if ((*ppStorageServer=tracker_make_connection(pNewStorage,
+		if ((*ppStorageServer=storage_make_connection(pNewStorage,
 			&result)) == NULL)
 		{
 			return result;
@@ -114,7 +210,7 @@ static int storage_get_connection(ConnectionInfo *pTrackerServer, \
 		}
 		else
 		{
-			if ((*ppStorageServer=tracker_make_connection(
+			if ((*ppStorageServer=storage_make_connection(
 				*ppStorageServer, &result)) == NULL)
 			{
 				return result;
@@ -163,7 +259,7 @@ static int storage_get_upload_connection(ConnectionInfo *pTrackerServer, \
 			return result;
 		}
 
-		if ((*ppStorageServer=tracker_make_connection(pNewStorage,
+		if ((*ppStorageServer=storage_make_connection(pNewStorage,
 			&result)) == NULL)
 		{
 			return result;
@@ -179,7 +275,7 @@ static int storage_get_upload_connection(ConnectionInfo *pTrackerServer, \
 		}
 		else
 		{
-			if ((*ppStorageServer=tracker_make_connection(
+			if ((*ppStorageServer=storage_make_connection(
 				*ppStorageServer, &result)) == NULL)
 			{
 				return result;
@@ -213,6 +309,7 @@ int storage_get_metadata(ConnectionInfo *pTrackerServer, \
 	int result;
 	ConnectionInfo storageServer;
 	char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+128];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	int64_t in_bytes;
 	int filename_len;
 	char *file_buff;
@@ -250,15 +347,15 @@ int storage_get_metadata(ConnectionInfo *pTrackerServer, \
 	long2buff(FDFS_GROUP_NAME_MAX_LEN + filename_len, pHeader->pkg_len);
 	pHeader->cmd = STORAGE_PROTO_CMD_GET_METADATA;
 
-	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
-			sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
+	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
+			sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN +
 			filename_len, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pStorageServer->ip_addr, pStorageServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+            pStorageServer->port, result, STRERROR(result));
 
 		break;
 	}
@@ -314,6 +411,7 @@ int storage_query_file_info_ex(ConnectionInfo *pTrackerServer, \
 	ConnectionInfo storageServer;
 	char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+128];
 	char in_buff[3 * FDFS_PROTO_PKG_LEN_SIZE + IP_ADDRESS_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char buff[64];
 	int64_t in_bytes;
 	int filename_len;
@@ -350,15 +448,15 @@ int storage_query_file_info_ex(ConnectionInfo *pTrackerServer, \
 	pHeader->cmd = STORAGE_PROTO_CMD_QUERY_FILE_INFO;
 	pHeader->status = bSilence ? ENOENT : 0;
 
-	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
-			sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
+	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
+			sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN +
 			filename_len, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pStorageServer->ip_addr, pStorageServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+            pStorageServer->port, result, STRERROR(result));
 
 		break;
 	}
@@ -375,25 +473,25 @@ int storage_query_file_info_ex(ConnectionInfo *pTrackerServer, \
 
 	if (in_bytes != sizeof(in_buff))
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"recv data from storage server %s:%u fail, " \
-			"recv bytes: %"PRId64" != %d", __LINE__, \
-			pStorageServer->ip_addr, pStorageServer->port, \
-			in_bytes, (int)sizeof(in_buff));
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"recv data from storage server %s:%u fail, "
+			"recv bytes: %"PRId64" != %d", __LINE__, formatted_ip,
+            pStorageServer->port, in_bytes, (int)sizeof(in_buff));
 		result = EINVAL;
 	}
 
-	if (!the_base64_context_inited)
+	if (!g_base64_context_inited)
 	{
-		the_base64_context_inited = 1;
-		base64_init_ex(&the_base64_context, 0, '-', '_', '.');
+		g_base64_context_inited = 1;
+		base64_init_ex(&g_fdfs_base64_context, 0, '-', '_', '.');
 	}
 
 	memset(buff, 0, sizeof(buff));
 	if (filename_len >= FDFS_LOGIC_FILE_PATH_LEN \
 		+ FDFS_FILENAME_BASE64_LENGTH + FDFS_FILE_EXT_NAME_MAX_LEN + 1)
 	{
-		base64_decode_auto(&the_base64_context, (char *)filename + \
+		base64_decode_auto(&g_fdfs_base64_context, (char *)filename + \
 			FDFS_LOGIC_FILE_PATH_LEN, FDFS_FILENAME_BASE64_LENGTH, \
 			buff, &buff_len);
 	}
@@ -447,6 +545,7 @@ int storage_delete_file(ConnectionInfo *pTrackerServer, \
 	int result;
 	ConnectionInfo storageServer;
 	char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+128];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char in_buff[1];
 	char *pBuff;
 	int64_t in_bytes;
@@ -480,15 +579,15 @@ int storage_delete_file(ConnectionInfo *pTrackerServer, \
 	long2buff(FDFS_GROUP_NAME_MAX_LEN + filename_len, pHeader->pkg_len);
 	pHeader->cmd = STORAGE_PROTO_CMD_DELETE_FILE;
 
-	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
-		sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
+	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
+		sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN +
 		filename_len, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pStorageServer->ip_addr, pStorageServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+            pStorageServer->port, result, STRERROR(result));
 		break;
 	}
 
@@ -536,6 +635,7 @@ int storage_do_download_file_ex(ConnectionInfo *pTrackerServer, \
 	int result;
 	ConnectionInfo storageServer;
 	char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+128];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char *p;
 	int out_bytes;
 	int64_t in_bytes;
@@ -570,21 +670,21 @@ int storage_do_download_file_ex(ConnectionInfo *pTrackerServer, \
 	p += 8;
 	snprintf(p, sizeof(out_buff) - (p - out_buff), "%s", group_name);
 	p += FDFS_GROUP_NAME_MAX_LEN;
-	filename_len = snprintf(p, sizeof(out_buff) - (p - out_buff), \
-				"%s", remote_filename);
+	filename_len = snprintf(p, sizeof(out_buff) -
+            (p - out_buff), "%s", remote_filename);
 	p += filename_len;
 	out_bytes = p - out_buff;
 	long2buff(out_bytes - sizeof(TrackerHeader), pHeader->pkg_len);
 	pHeader->cmd = STORAGE_PROTO_CMD_DOWNLOAD_FILE;
 
-	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
+	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
 		out_bytes, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pStorageServer->ip_addr, pStorageServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+            pStorageServer->port, result, STRERROR(result));
 		break;
 	}
 
@@ -648,15 +748,14 @@ int storage_do_download_file_ex(ConnectionInfo *pTrackerServer, \
 				recv_bytes = remain_bytes;
 			}
 
-			if ((result=tcprecvdata_nb(pStorageServer->sock, buff, \
+			if ((result=tcprecvdata_nb(pStorageServer->sock, buff,
 				recv_bytes, SF_G_NETWORK_TIMEOUT)) != 0)
 			{
-				logError("file: "__FILE__", line: %d, " \
-					"recv data from storage server " \
-					"%s:%u fail, " \
-					"errno: %d, error info: %s", __LINE__, \
-					pStorageServer->ip_addr, \
-					pStorageServer->port, \
+                format_ip_address(pStorageServer->ip_addr, formatted_ip);
+				logError("file: "__FILE__", line: %d, "
+					"recv data from storage server %s:%u fail, "
+					"errno: %d, error info: %s", __LINE__, 
+                    formatted_ip, pStorageServer->port,
 					result, STRERROR(result));
 				break;
 			}
@@ -821,9 +920,10 @@ int storage_do_upload_file(ConnectionInfo *pTrackerServer, \
 	int64_t in_bytes;
 	int64_t total_send_bytes;
 	char in_buff[128];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char *pInBuff;
 	ConnectionInfo storageServer;
-	bool new_connection;
+	bool new_connection = false;
 	bool bUploadSlave;
 	int new_store_path;
 	int master_filename_len;
@@ -852,26 +952,30 @@ int storage_do_upload_file(ConnectionInfo *pTrackerServer, \
 	bUploadSlave = (strlen(group_name) > 0 && master_filename_len > 0);
 	if (bUploadSlave)
 	{
-		if ((result=storage_get_update_connection(pTrackerServer, \
-			&pStorageServer, group_name, master_filename, \
+		if ((result=storage_get_update_connection(pTrackerServer,
+			&pStorageServer, group_name, master_filename,
 			&storageServer, &new_connection)) != 0)
 		{
 			return result;
 		}
 	}
-	else if ((result=storage_get_upload_connection(pTrackerServer, \
-		&pStorageServer, group_name, &storageServer, \
-		&new_store_path, &new_connection)) != 0)
-	{
-		*group_name = '\0';
-		return result;
-	}
+    else
+    {
+        if ((result=storage_get_upload_connection(pTrackerServer,
+                        &pStorageServer, group_name, &storageServer,
+                        &new_store_path, &new_connection)) != 0)
+        {
+            *group_name = '\0';
+            return result;
+        }
+    }
 
 	*group_name = '\0';
 
 	/*
+       format_ip_address(pStorageServer->ip_addr, formatted_ip);
 	//logInfo("upload to storage %s:%u\n", \
-		pStorageServer->ip_addr, pStorageServer->port);
+		formatted_ip, pStorageServer->port);
 	*/
 
 	do
@@ -937,14 +1041,14 @@ int storage_do_upload_file(ConnectionInfo *pTrackerServer, \
 	pHeader->cmd = cmd;
 	pHeader->status = 0;
 
-	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
+	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
 		p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pStorageServer->ip_addr, pStorageServer->port, \
-			result, STRERROR(result));
+       format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+            pStorageServer->port, result, STRERROR(result));
 		break;
 	}
 
@@ -959,15 +1063,15 @@ int storage_do_upload_file(ConnectionInfo *pTrackerServer, \
 	}
 	else if (upload_type == FDFS_UPLOAD_BY_BUFF)
 	{
-		if ((result=tcpsenddata_nb(pStorageServer->sock, \
-			(char *)file_buff, file_size, \
+		if ((result=tcpsenddata_nb(pStorageServer->sock,
+			(char *)file_buff, file_size,
 			SF_G_NETWORK_TIMEOUT)) != 0)
 		{
-			logError("file: "__FILE__", line: %d, " \
-				"send data to storage server %s:%u fail, " \
-				"errno: %d, error info: %s", __LINE__, \
-				pStorageServer->ip_addr, pStorageServer->port, \
-				result, STRERROR(result));
+            format_ip_address(pStorageServer->ip_addr, formatted_ip);
+			logError("file: "__FILE__", line: %d, "
+				"send data to storage server %s:%u fail, "
+				"errno: %d, error info: %s", __LINE__,  formatted_ip,
+                pStorageServer->port, result, STRERROR(result));
 			break;
 		}
 	}
@@ -993,12 +1097,11 @@ int storage_do_upload_file(ConnectionInfo *pTrackerServer, \
 
 	if (in_bytes <= FDFS_GROUP_NAME_MAX_LEN)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"storage server %s:%u response data " \
-			"length: %"PRId64" is invalid, " \
-			"should > %d", __LINE__, \
-			pStorageServer->ip_addr, pStorageServer->port, \
-			in_bytes, FDFS_GROUP_NAME_MAX_LEN);
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"storage server %s:%u response data length: %"PRId64" "
+            "is invalid, should > %d", __LINE__, formatted_ip,
+            pStorageServer->port, in_bytes, FDFS_GROUP_NAME_MAX_LEN);
 		result = EINVAL;
 		break;
 	}
@@ -1158,6 +1261,7 @@ int storage_set_metadata(ConnectionInfo *pTrackerServer, \
 	ConnectionInfo storageServer;
 	char out_buff[sizeof(TrackerHeader)+2*FDFS_PROTO_PKG_LEN_SIZE+\
 			FDFS_GROUP_NAME_MAX_LEN+128];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char in_buff[1];
 	int64_t in_bytes;
 	char *pBuff;
@@ -1168,8 +1272,8 @@ int storage_set_metadata(ConnectionInfo *pTrackerServer, \
 	char *pEnd;
 	bool new_connection;
 
-	if ((result=storage_get_update_connection(pTrackerServer, \
-		&pStorageServer, group_name, filename, \
+	if ((result=storage_get_update_connection(pTrackerServer,
+		&pStorageServer, group_name, filename,
 		&storageServer, &new_connection)) != 0)
 	{
 		return result;
@@ -1214,30 +1318,29 @@ int storage_set_metadata(ConnectionInfo *pTrackerServer, \
 	p += filename_len;
 
 	pHeader = (TrackerHeader *)out_buff;
-	long2buff((int)(p - (out_buff + sizeof(TrackerHeader))) + \
+	long2buff((int)(p - (out_buff + sizeof(TrackerHeader))) +
 		meta_bytes, pHeader->pkg_len);
 	pHeader->cmd = STORAGE_PROTO_CMD_SET_METADATA;
 
-	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
+	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
 			p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pStorageServer->ip_addr, pStorageServer->port, \
-			result, STRERROR(result));
-
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+            pStorageServer->port, result, STRERROR(result));
 		break;
 	}
 
-	if (meta_bytes > 0 && (result=tcpsenddata_nb(pStorageServer->sock, \
+	if (meta_bytes > 0 && (result=tcpsenddata_nb(pStorageServer->sock,
 			meta_buff, meta_bytes, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pStorageServer->ip_addr, pStorageServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+            pStorageServer->port, result, STRERROR(result));
 		break;
 	}
 
@@ -1338,6 +1441,7 @@ int storage_client_create_link(ConnectionInfo *pTrackerServer, \
 		FDFS_GROUP_NAME_MAX_LEN + FDFS_FILE_PREFIX_MAX_LEN + \
 		FDFS_FILE_EXT_NAME_MAX_LEN + 256];
 	char in_buff[128];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char *p;
 	int group_name_len;
 	int master_filename_len;
@@ -1435,11 +1539,11 @@ int storage_client_create_link(ConnectionInfo *pTrackerServer, \
 	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
 		p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pStorageServer->ip_addr, pStorageServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+            pStorageServer->port, result, STRERROR(result));
 		break;
 	}
 
@@ -1455,12 +1559,11 @@ int storage_client_create_link(ConnectionInfo *pTrackerServer, \
 
 	if (in_bytes <= FDFS_GROUP_NAME_MAX_LEN)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"storage server %s:%u response data " \
-			"length: %"PRId64" is invalid, " \
-			"should > %d", __LINE__, \
-			pStorageServer->ip_addr, pStorageServer->port, \
-			in_bytes, FDFS_GROUP_NAME_MAX_LEN);
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"storage server %s:%u response data length: %"PRId64" "
+            "is invalid, should > %d", __LINE__, formatted_ip,
+            pStorageServer->port, in_bytes, FDFS_GROUP_NAME_MAX_LEN);
 		result = EINVAL;
 		break;
 	}
@@ -1689,6 +1792,7 @@ int storage_do_append_file(ConnectionInfo *pTrackerServer, \
 	TrackerHeader *pHeader;
 	int result;
 	char out_buff[512];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char *p;
 	int64_t in_bytes;
 	int64_t total_send_bytes;
@@ -1706,8 +1810,9 @@ int storage_do_append_file(ConnectionInfo *pTrackerServer, \
 	}
 
 	/*
+    format_ip_address(pStorageServer->ip_addr, formatted_ip);
 	//printf("upload to storage %s:%u\n", \
-		pStorageServer->ip_addr, pStorageServer->port);
+		formatted_ip, pStorageServer->port);
 	*/
 
 	do
@@ -1723,19 +1828,19 @@ int storage_do_append_file(ConnectionInfo *pTrackerServer, \
 	memcpy(p, appender_filename, appender_filename_len);
 	p += appender_filename_len;
 
-	long2buff((p - out_buff) + file_size - sizeof(TrackerHeader), \
+	long2buff((p - out_buff) + file_size - sizeof(TrackerHeader),
 		pHeader->pkg_len);
 	pHeader->cmd = STORAGE_PROTO_CMD_APPEND_FILE;
 	pHeader->status = 0;
 
-	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
+	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
 		p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pStorageServer->ip_addr, pStorageServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+            pStorageServer->port, result, STRERROR(result));
 		break;
 	}
 
@@ -1750,15 +1855,15 @@ int storage_do_append_file(ConnectionInfo *pTrackerServer, \
 	}
 	else if (upload_type == FDFS_UPLOAD_BY_BUFF)
 	{
-		if ((result=tcpsenddata_nb(pStorageServer->sock, \
-			(char *)file_buff, file_size, \
+		if ((result=tcpsenddata_nb(pStorageServer->sock,
+			(char *)file_buff, file_size,
 			SF_G_NETWORK_TIMEOUT)) != 0)
 		{
-			logError("file: "__FILE__", line: %d, " \
-				"send data to storage server %s:%u fail, " \
-				"errno: %d, error info: %s", __LINE__, \
-				pStorageServer->ip_addr, pStorageServer->port, \
-				result, STRERROR(result));
+            format_ip_address(pStorageServer->ip_addr, formatted_ip);
+			logError("file: "__FILE__", line: %d, "
+				"send data to storage server %s:%u fail, "
+				"errno: %d, error info: %s", __LINE__, formatted_ip,
+                pStorageServer->port, result, STRERROR(result));
 			break;
 		}
 	}
@@ -1782,10 +1887,10 @@ int storage_do_append_file(ConnectionInfo *pTrackerServer, \
 
 	if (in_bytes != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"storage server %s:%u response data " \
-			"length: %"PRId64" is invalid, " \
-			"should == 0", __LINE__, pStorageServer->ip_addr, \
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"storage server %s:%u response data length: %"PRId64" "
+            "is invalid, should == 0", __LINE__, formatted_ip,
 			pStorageServer->port, in_bytes);
 		result = EINVAL;
 		break;
@@ -1818,6 +1923,7 @@ int storage_do_modify_file(ConnectionInfo *pTrackerServer, \
 	TrackerHeader *pHeader;
 	int result;
 	char out_buff[512];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char *p;
 	int64_t in_bytes;
 	int64_t total_send_bytes;
@@ -1834,8 +1940,9 @@ int storage_do_modify_file(ConnectionInfo *pTrackerServer, \
 	}
 
 	/*
+    format_ip_address(pStorageServer->ip_addr, formatted_ip);
 	//printf("upload to storage %s:%u\n", \
-		pStorageServer->ip_addr, pStorageServer->port);
+		formatted_ip, pStorageServer->port);
 	*/
 
 	do
@@ -1854,42 +1961,41 @@ int storage_do_modify_file(ConnectionInfo *pTrackerServer, \
 	memcpy(p, appender_filename, appender_filename_len);
 	p += appender_filename_len;
 
-	long2buff((p - out_buff) + file_size - sizeof(TrackerHeader), \
+	long2buff((p - out_buff) + file_size - sizeof(TrackerHeader),
 		pHeader->pkg_len);
 	pHeader->cmd = STORAGE_PROTO_CMD_MODIFY_FILE;
 	pHeader->status = 0;
 
-	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
+	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
 		p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pStorageServer->ip_addr, pStorageServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+            pStorageServer->port, result, STRERROR(result));
 		break;
 	}
 
 	if (upload_type == FDFS_UPLOAD_BY_FILE)
 	{
-		if ((result=tcpsendfile(pStorageServer->sock, file_buff, \
-			file_size, SF_G_NETWORK_TIMEOUT, \
-			&total_send_bytes)) != 0)
+		if ((result=tcpsendfile(pStorageServer->sock, file_buff,
+			file_size, SF_G_NETWORK_TIMEOUT, &total_send_bytes)) != 0)
 		{
 			break;
 		}
 	}
 	else if (upload_type == FDFS_UPLOAD_BY_BUFF)
 	{
-		if ((result=tcpsenddata_nb(pStorageServer->sock, \
-			(char *)file_buff, file_size, \
+		if ((result=tcpsenddata_nb(pStorageServer->sock,
+			(char *)file_buff, file_size,
 			SF_G_NETWORK_TIMEOUT)) != 0)
 		{
-			logError("file: "__FILE__", line: %d, " \
-				"send data to storage server %s:%u fail, " \
-				"errno: %d, error info: %s", __LINE__, \
-				pStorageServer->ip_addr, pStorageServer->port, \
-				result, STRERROR(result));
+            format_ip_address(pStorageServer->ip_addr, formatted_ip);
+			logError("file: "__FILE__", line: %d, "
+				"send data to storage server %s:%u fail, "
+				"errno: %d, error info: %s", __LINE__, formatted_ip,
+                pStorageServer->port, result, STRERROR(result));
 			break;
 		}
 	}
@@ -1913,10 +2019,10 @@ int storage_do_modify_file(ConnectionInfo *pTrackerServer, \
 
 	if (in_bytes != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"storage server %s:%u response data " \
-			"length: %"PRId64" is invalid, " \
-			"should == 0", __LINE__, pStorageServer->ip_addr, \
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"storage server %s:%u response data length: %"PRId64" "
+            "is invalid, should == 0", __LINE__, formatted_ip,
 			pStorageServer->port, in_bytes);
 		result = EINVAL;
 		break;
@@ -2139,10 +2245,10 @@ int fdfs_get_file_info_ex(const char *group_name, const char *remote_filename, \
 	char buff[64];
 
 	memset(pFileInfo, 0, sizeof(FDFSFileInfo));
-	if (!the_base64_context_inited)
+	if (!g_base64_context_inited)
 	{
-		the_base64_context_inited = 1;
-		base64_init_ex(&the_base64_context, 0, '-', '_', '.');
+		g_base64_context_inited = 1;
+		base64_init_ex(&g_fdfs_base64_context, 0, '-', '_', '.');
 	}
 
 	filename_len = strlen(remote_filename);
@@ -2156,7 +2262,7 @@ int fdfs_get_file_info_ex(const char *group_name, const char *remote_filename, \
 	}
 
 	memset(buff, 0, sizeof(buff));
-	base64_decode_auto(&the_base64_context, (char *)remote_filename + \
+	base64_decode_auto(&g_fdfs_base64_context, (char *)remote_filename + \
 		FDFS_LOGIC_FILE_PATH_LEN, FDFS_FILENAME_BASE64_LENGTH, \
 		buff, &buff_len);
 
@@ -2286,6 +2392,7 @@ int storage_truncate_file(ConnectionInfo *pTrackerServer, \
 	TrackerHeader *pHeader;
 	int result;
 	char out_buff[512];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char *p;
 	int64_t in_bytes;
 	ConnectionInfo storageServer;
@@ -2301,8 +2408,9 @@ int storage_truncate_file(ConnectionInfo *pTrackerServer, \
 	}
 
 	/*
+    format_ip_address(pStorageServer->ip_addr, formatted_ip);
 	//printf("upload to storage %s:%u\n", \
-		pStorageServer->ip_addr, pStorageServer->port);
+		formatted_ip, pStorageServer->port);
 	*/
 
 	do
@@ -2318,19 +2426,19 @@ int storage_truncate_file(ConnectionInfo *pTrackerServer, \
 	memcpy(p, appender_filename, appender_filename_len);
 	p += appender_filename_len;
 
-	long2buff((p - out_buff) - sizeof(TrackerHeader), \
+	long2buff((p - out_buff) - sizeof(TrackerHeader),
 		pHeader->pkg_len);
 	pHeader->cmd = STORAGE_PROTO_CMD_TRUNCATE_FILE;
 	pHeader->status = 0;
 
-	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
+	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
 		p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pStorageServer->ip_addr, pStorageServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+            pStorageServer->port, result, STRERROR(result));
 		break;
 	}
 
@@ -2344,10 +2452,10 @@ int storage_truncate_file(ConnectionInfo *pTrackerServer, \
 
 	if (in_bytes != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"storage server %s:%u response data " \
-			"length: %"PRId64" is invalid, " \
-			"should == 0", __LINE__, pStorageServer->ip_addr, \
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"storage server %s:%u response data length: %"PRId64" "
+            "is invalid, should == 0", __LINE__, formatted_ip,
 			pStorageServer->port, in_bytes);
 		result = EINVAL;
 		break;
@@ -2371,6 +2479,7 @@ int storage_regenerate_appender_filename(ConnectionInfo *pTrackerServer,
 	int result;
 	char out_buff[512];
 	char in_buff[256];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char *p;
 	char *pInBuff;
 	int64_t in_bytes;
@@ -2402,11 +2511,11 @@ int storage_regenerate_appender_filename(ConnectionInfo *pTrackerServer,
 	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
 		p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
 		logError("file: "__FILE__", line: %d, "
 			"send data to storage server %s:%u fail, "
-			"errno: %d, error info: %s", __LINE__,
-			pStorageServer->ip_addr, pStorageServer->port,
-			result, STRERROR(result));
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+            pStorageServer->port, result, STRERROR(result));
 		break;
 	}
 
@@ -2422,12 +2531,11 @@ int storage_regenerate_appender_filename(ConnectionInfo *pTrackerServer,
 
 	if (in_bytes <= FDFS_GROUP_NAME_MAX_LEN)
 	{
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
 		logError("file: "__FILE__", line: %d, "
-			"storage server %s:%u response data "
-			"length: %"PRId64" is invalid, "
-			"should > %d", __LINE__,
-			pStorageServer->ip_addr, pStorageServer->port,
-			in_bytes, FDFS_GROUP_NAME_MAX_LEN);
+			"storage server %s:%u response data length: %"PRId64" "
+            "is invalid, should > %d", __LINE__, formatted_ip,
+            pStorageServer->port, in_bytes, FDFS_GROUP_NAME_MAX_LEN);
 		result = EINVAL;
 		break;
 	}

client/tracker_client.c

@@ -249,6 +249,7 @@ int tracker_list_servers(ConnectionInfo *pTrackerServer, \
 {
 	char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
 			IP_ADDRESS_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	bool new_connection;
 	TrackerHeader *pHeader;
 	ConnectionInfo *conn;
@@ -293,17 +294,16 @@ int tracker_list_servers(ConnectionInfo *pTrackerServer, \
 
 	long2buff(FDFS_GROUP_NAME_MAX_LEN + id_len, pHeader->pkg_len);
 	pHeader->cmd = TRACKER_PROTO_CMD_SERVER_LIST_STORAGE;
-	if ((result=tcpsenddata_nb(conn->sock, out_buff, \
-		sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + id_len, \
+	if ((result=tcpsenddata_nb(conn->sock, out_buff,
+		sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + id_len,
 		SF_G_NETWORK_TIMEOUT)) != 0)
-	{
-		logError("file: "__FILE__", line: %d, " \
-		        "send data to tracker server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pTrackerServer->ip_addr, \
-			pTrackerServer->port, \
-			result, STRERROR(result));
-	}
+    {
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+        logError("file: "__FILE__", line: %d, "
+                "send data to tracker server %s:%u fail, errno: %d, "
+                "error info: %s", __LINE__, formatted_ip,
+                pTrackerServer->port, result, STRERROR(result));
+    }
 	else
 	{
 		pInBuff = (char *)stats;
@@ -330,10 +330,10 @@ int tracker_list_servers(ConnectionInfo *pTrackerServer, \
 
 	if (in_bytes % sizeof(TrackerStorageStat) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u response data " \
-			"length: %"PRId64" is invalid", \
-			__LINE__, pTrackerServer->ip_addr, \
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u response data length: %"PRId64
+			" is invalid", __LINE__, formatted_ip,
 			pTrackerServer->port, in_bytes);
 		*storage_count = 0;
 		return EINVAL;
@@ -342,11 +342,12 @@ int tracker_list_servers(ConnectionInfo *pTrackerServer, \
 	*storage_count = in_bytes / sizeof(TrackerStorageStat);
 	if (*storage_count > max_storages)
 	{
-		logError("file: "__FILE__", line: %d, " \
-		 	"tracker server %s:%u insufficent space, " \
-			"max storage count: %d, expect count: %d", \
-			__LINE__, pTrackerServer->ip_addr, \
-			pTrackerServer->port, max_storages, *storage_count);
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+		 	"tracker server %s:%u insufficent space, "
+			"max storage count: %d, expect count: %d",
+			__LINE__, formatted_ip, pTrackerServer->port,
+            max_storages, *storage_count);
 		*storage_count = 0;
 		return ENOSPC;
 	}
@@ -484,6 +485,7 @@ int tracker_list_one_group(ConnectionInfo *pTrackerServer, \
 	ConnectionInfo *conn;
 	bool new_connection;
 	char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	TrackerGroupStat src;
 	char *pInBuff;
 	int result;
@@ -497,15 +499,14 @@ int tracker_list_one_group(ConnectionInfo *pTrackerServer, \
 			sizeof(TrackerHeader),  "%s", group_name);
 	pHeader->cmd = TRACKER_PROTO_CMD_SERVER_LIST_ONE_GROUP;
 	long2buff(FDFS_GROUP_NAME_MAX_LEN, pHeader->pkg_len);
-	if ((result=tcpsenddata_nb(conn->sock, out_buff, \
+	if ((result=tcpsenddata_nb(conn->sock, out_buff,
 			sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to tracker server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pTrackerServer->ip_addr, \
-			pTrackerServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to tracker server %s:%u fail, errno: %d, "
+			"error info: %s", __LINE__, formatted_ip,
+			pTrackerServer->port, result, STRERROR(result));
 	}
 	else
 	{
@@ -532,10 +533,10 @@ int tracker_list_one_group(ConnectionInfo *pTrackerServer, \
 
 	if (in_bytes != sizeof(TrackerGroupStat))
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u response data " \
-			"length: %"PRId64" is invalid", \
-			__LINE__, pTrackerServer->ip_addr, \
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u response data length: %"PRId64" "
+            "is invalid", __LINE__, formatted_ip,
 			pTrackerServer->port, in_bytes);
 		return EINVAL;
 	}
@@ -569,6 +570,7 @@ int tracker_list_groups(ConnectionInfo *pTrackerServer, \
 	TrackerGroupStat *pSrc;
 	TrackerGroupStat *pEnd;
 	FDFSGroupStat *pDest;
+    char formatted_ip[FORMATTED_IP_SIZE];
 	int result;
 	int64_t in_bytes;
 
@@ -577,15 +579,14 @@ int tracker_list_groups(ConnectionInfo *pTrackerServer, \
 	memset(&header, 0, sizeof(header));
 	header.cmd = TRACKER_PROTO_CMD_SERVER_LIST_ALL_GROUPS;
 	header.status = 0;
-	if ((result=tcpsenddata_nb(conn->sock, &header, \
+	if ((result=tcpsenddata_nb(conn->sock, &header,
 			sizeof(header), SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to tracker server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pTrackerServer->ip_addr, \
-			pTrackerServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to tracker server %s:%u fail, errno: %d, "
+			"error info: %s", __LINE__, formatted_ip,
+			pTrackerServer->port, result, STRERROR(result));
 	}
 	else
 	{
@@ -613,10 +614,10 @@ int tracker_list_groups(ConnectionInfo *pTrackerServer, \
 
 	if (in_bytes % sizeof(TrackerGroupStat) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u response data " \
-			"length: %"PRId64" is invalid", \
-			__LINE__, pTrackerServer->ip_addr, \
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u response data length: %"PRId64" "
+            "is invalid", __LINE__, formatted_ip,
 			pTrackerServer->port, in_bytes);
 		*group_count = 0;
 		return EINVAL;
@@ -625,11 +626,12 @@ int tracker_list_groups(ConnectionInfo *pTrackerServer, \
 	*group_count = in_bytes / sizeof(TrackerGroupStat);
 	if (*group_count > max_groups)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u insufficent space, " \
-			"max group count: %d, expect count: %d", \
-			__LINE__, pTrackerServer->ip_addr, \
-			pTrackerServer->port, max_groups, *group_count);
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u insufficent space, "
+			"max group count: %d, expect count: %d",
+			__LINE__, formatted_ip, pTrackerServer->port,
+            max_groups, *group_count);
 		*group_count = 0;
 		return ENOSPC;
 	}
@@ -672,6 +674,7 @@ int tracker_do_query_storage(ConnectionInfo *pTrackerServer, \
 	bool new_connection;
 	char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + 128];
 	char in_buff[sizeof(TrackerHeader) + TRACKER_QUERY_STORAGE_FETCH_BODY_LEN];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char *pInBuff;
 	int64_t in_bytes;
 	int result;
@@ -693,16 +696,15 @@ int tracker_do_query_storage(ConnectionInfo *pTrackerServer, \
 	
 	long2buff(FDFS_GROUP_NAME_MAX_LEN + filename_len, pHeader->pkg_len);
 	pHeader->cmd = cmd;
-	if ((result=tcpsenddata_nb(conn->sock, out_buff, \
+	if ((result=tcpsenddata_nb(conn->sock, out_buff,
 		sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + 
 		filename_len, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to tracker server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pTrackerServer->ip_addr, \
-			pTrackerServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to tracker server %s:%u fail, errno: %d, "
+			"error info: %s", __LINE__, formatted_ip,
+			pTrackerServer->port, result, STRERROR(result));
 	}
 	else
 	{
@@ -729,12 +731,11 @@ int tracker_do_query_storage(ConnectionInfo *pTrackerServer, \
 
 	if (in_bytes != TRACKER_QUERY_STORAGE_FETCH_BODY_LEN)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u response data " \
-			"length: %"PRId64" is invalid, " \
-			"expect length: %d", __LINE__, \
-			pTrackerServer->ip_addr, \
-			pTrackerServer->port, in_bytes, \
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u response data length: %"PRId64" "
+            "is invalid, expect length: %d", __LINE__,
+            formatted_ip, pTrackerServer->port, in_bytes,
 			TRACKER_QUERY_STORAGE_FETCH_BODY_LEN);
 		return EINVAL;
 	}
@@ -759,6 +760,7 @@ int tracker_query_storage_list(ConnectionInfo *pTrackerServer, \
 	char in_buff[sizeof(TrackerHeader) + \
 		TRACKER_QUERY_STORAGE_FETCH_BODY_LEN + \
 		FDFS_MAX_SERVERS_EACH_GROUP * IP_ADDRESS_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char *pInBuff;
 	int64_t in_bytes;
 	int result;
@@ -781,12 +783,11 @@ int tracker_query_storage_list(ConnectionInfo *pTrackerServer, \
 		sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + 
 		filename_len, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to tracker server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pTrackerServer->ip_addr, \
-			pTrackerServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to tracker server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+			pTrackerServer->port, result, STRERROR(result));
 	}
 	else
 	{
@@ -814,10 +815,10 @@ int tracker_query_storage_list(ConnectionInfo *pTrackerServer, \
 	if ((in_bytes - TRACKER_QUERY_STORAGE_FETCH_BODY_LEN) % \
 		(IP_ADDRESS_SIZE - 1) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u response data " \
-			"length: %"PRId64" is invalid", \
-			__LINE__, pTrackerServer->ip_addr, \
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u response data length: %"PRId64" "
+            "is invalid", __LINE__, formatted_ip,
 			pTrackerServer->port, in_bytes);
 		return EINVAL;
 	}
@@ -826,10 +827,11 @@ int tracker_query_storage_list(ConnectionInfo *pTrackerServer, \
 			(IP_ADDRESS_SIZE - 1);
 	if (nMaxServerCount < *server_count)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u response storage server " \
-			 "count: %d, exceeds max server count: %d!", __LINE__, \
-			pTrackerServer->ip_addr, pTrackerServer->port, \
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u response storage server "
+			 "count: %d, exceeds max server count: %d!", __LINE__,
+			formatted_ip, pTrackerServer->port,
 			*server_count, nMaxServerCount);
 		return ENOSPC;
 	}
@@ -864,6 +866,7 @@ int tracker_query_storage_store_without_group(ConnectionInfo *pTrackerServer,
 	TrackerHeader header;
 	char in_buff[sizeof(TrackerHeader) + \
 		TRACKER_QUERY_STORAGE_STORE_BODY_LEN];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	bool new_connection;
 	ConnectionInfo *conn;
 	char *pInBuff;
@@ -880,12 +883,11 @@ int tracker_query_storage_store_without_group(ConnectionInfo *pTrackerServer,
 	if ((result=tcpsenddata_nb(conn->sock, &header, \
 			sizeof(header), SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to tracker server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pTrackerServer->ip_addr, \
-			pTrackerServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to tracker server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+			pTrackerServer->port, result, STRERROR(result));
 	}
 	else
 	{
@@ -912,12 +914,12 @@ int tracker_query_storage_store_without_group(ConnectionInfo *pTrackerServer,
 
 	if (in_bytes != TRACKER_QUERY_STORAGE_STORE_BODY_LEN)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u response data " \
-			"length: %"PRId64" is invalid, " \
-			"expect length: %d", __LINE__, \
-			pTrackerServer->ip_addr, pTrackerServer->port, \
-			in_bytes, TRACKER_QUERY_STORAGE_STORE_BODY_LEN);
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u response data length: %"PRId64" "
+            "is invalid, expect length: %d", __LINE__,
+            formatted_ip, pTrackerServer->port, in_bytes,
+            TRACKER_QUERY_STORAGE_STORE_BODY_LEN);
 		return EINVAL;
 	}
 
@@ -943,6 +945,7 @@ int tracker_query_storage_store_with_group(ConnectionInfo *pTrackerServer, \
 	char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN];
 	char in_buff[sizeof(TrackerHeader) + \
 		TRACKER_QUERY_STORAGE_STORE_BODY_LEN];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char *pInBuff;
 	int64_t in_bytes;
 	int result;
@@ -959,16 +962,15 @@ int tracker_query_storage_store_with_group(ConnectionInfo *pTrackerServer, \
 	
 	long2buff(FDFS_GROUP_NAME_MAX_LEN, pHeader->pkg_len);
 	pHeader->cmd = TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITH_GROUP_ONE;
-	if ((result=tcpsenddata_nb(conn->sock, out_buff, \
-			sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN, \
+	if ((result=tcpsenddata_nb(conn->sock, out_buff,
+			sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN,
 			SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to tracker server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pTrackerServer->ip_addr, \
-			pTrackerServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to tracker server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+			pTrackerServer->port, result, STRERROR(result));
 	}
 	else
 	{
@@ -995,11 +997,11 @@ int tracker_query_storage_store_with_group(ConnectionInfo *pTrackerServer, \
 
 	if (in_bytes != TRACKER_QUERY_STORAGE_STORE_BODY_LEN)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u response data " \
-			"length: %"PRId64" is invalid, " \
-			"expect length: %d", __LINE__, \
-			pTrackerServer->ip_addr, pTrackerServer->port, \
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u response data "
+			"length: %"PRId64" is invalid, expect length: %d",
+            __LINE__, formatted_ip, pTrackerServer->port,
 			in_bytes, TRACKER_QUERY_STORAGE_STORE_BODY_LEN);
 		return EINVAL;
 	}
@@ -1027,6 +1029,7 @@ int tracker_query_storage_store_list_with_group( \
 	char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN];
 	char in_buff[sizeof(TrackerHeader) + FDFS_MAX_SERVERS_EACH_GROUP * \
 			TRACKER_QUERY_STORAGE_STORE_BODY_LEN];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char returned_group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
 	char *pInBuff;
 	char *p;
@@ -1055,15 +1058,14 @@ int tracker_query_storage_store_list_with_group( \
 	}
 
 	long2buff(out_len, pHeader->pkg_len);
-	if ((result=tcpsenddata_nb(conn->sock, out_buff, \
+	if ((result=tcpsenddata_nb(conn->sock, out_buff,
 		sizeof(TrackerHeader) + out_len, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to tracker server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pTrackerServer->ip_addr, \
-			pTrackerServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to tracker server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+			pTrackerServer->port, result, STRERROR(result));
 	}
 	else
 	{
@@ -1090,11 +1092,11 @@ int tracker_query_storage_store_list_with_group( \
 
 	if (in_bytes < TRACKER_QUERY_STORAGE_STORE_BODY_LEN)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u response data " \
-			"length: %"PRId64" is invalid, " \
-			"expect length >= %d", __LINE__, \
-			pTrackerServer->ip_addr, pTrackerServer->port, \
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u response data "
+			"length: %"PRId64" is invalid, expect length >= %d",
+            __LINE__, formatted_ip, pTrackerServer->port,
 			in_bytes, TRACKER_QUERY_STORAGE_STORE_BODY_LEN);
 		return EINVAL;
 	}
@@ -1104,22 +1106,23 @@ int tracker_query_storage_store_list_with_group( \
 	ipPortsLen = in_bytes - (FDFS_GROUP_NAME_MAX_LEN + 1);
 	if (ipPortsLen % RECORD_LENGTH != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u response data " \
-			"length: %"PRId64" is invalid", \
-			__LINE__, pTrackerServer->ip_addr, \
-			pTrackerServer->port, in_bytes);
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u response data "
+			"length: %"PRId64" is invalid", __LINE__,
+            formatted_ip, pTrackerServer->port, in_bytes);
 		return EINVAL;
 	}
 
 	*storage_count = ipPortsLen / RECORD_LENGTH;
 	if (nMaxServerCount < *storage_count)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u response storage server " \
-			 "count: %d, exceeds max server count: %d!", \
-			__LINE__, pTrackerServer->ip_addr, \
-			pTrackerServer->port, *storage_count, nMaxServerCount);
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u response storage server "
+			 "count: %d, exceeds max server count: %d!",
+			__LINE__, formatted_ip, pTrackerServer->port,
+            *storage_count, nMaxServerCount);
 		return ENOSPC;
 	}
 
@@ -1157,6 +1160,7 @@ int tracker_delete_storage(TrackerServerGroup *pTrackerGroup, \
 	FDFSStorageInfo storage_infos[1];
 	char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
 			FDFS_STORAGE_ID_MAX_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char in_buff[1];
 	char *pInBuff;
 	int64_t in_bytes;
@@ -1228,11 +1232,11 @@ int tracker_delete_storage(TrackerServerGroup *pTrackerGroup, \
 			sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + 
 			storage_id_len, SF_G_NETWORK_TIMEOUT)) != 0)
 		{
+            format_ip_address(conn->ip_addr, formatted_ip);
 			logError("file: "__FILE__", line: %d, "
 				"send data to tracker server %s:%u fail, "
-				"errno: %d, error info: %s", __LINE__,
-				conn->ip_addr, conn->port,
-				result, STRERROR(result));
+				"errno: %d, error info: %s", __LINE__, formatted_ip,
+                conn->port, result, STRERROR(result));
 		}
 		else
 		{
@@ -1280,6 +1284,7 @@ int tracker_delete_group(TrackerServerGroup *pTrackerGroup, \
 	TrackerServerInfo *pServer;
 	TrackerServerInfo *pEnd;
 	char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN]; 
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char in_buff[1];
 	char *pInBuff;
 	int64_t in_bytes;
@@ -1308,11 +1313,11 @@ int tracker_delete_group(TrackerServerGroup *pTrackerGroup, \
 			sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN,
             SF_G_NETWORK_TIMEOUT)) != 0)
 		{
+            format_ip_address(conn->ip_addr, formatted_ip);
 			logError("file: "__FILE__", line: %d, "
 				"send data to tracker server %s:%u fail, "
-				"errno: %d, error info: %s", __LINE__,
-				conn->ip_addr, conn->port,
-				result, STRERROR(result));
+				"errno: %d, error info: %s", __LINE__, formatted_ip,
+                conn->port, result, STRERROR(result));
             break;
 		}
 
@@ -1343,6 +1348,7 @@ int tracker_set_trunk_server(TrackerServerGroup *pTrackerGroup, \
 	char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
 			FDFS_STORAGE_ID_MAX_SIZE];
 	char in_buff[FDFS_STORAGE_ID_MAX_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char *pInBuff;
 	int64_t in_bytes;
 	int result;
@@ -1380,15 +1386,15 @@ int tracker_set_trunk_server(TrackerServerGroup *pTrackerGroup, \
 			continue;
 		}
 
-		if ((result=tcpsenddata_nb(conn->sock, out_buff, \
+		if ((result=tcpsenddata_nb(conn->sock, out_buff,
 			sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + 
 			storage_id_len, SF_G_NETWORK_TIMEOUT)) != 0)
 		{
+            format_ip_address(conn->ip_addr, formatted_ip);
 			logError("file: "__FILE__", line: %d, "
 				"send data to tracker server %s:%u fail, "
-				"errno: %d, error info: %s", __LINE__,
-				conn->ip_addr, conn->port,
-				result, STRERROR(result));
+				"errno: %d, error info: %s", __LINE__, formatted_ip,
+                conn->port, result, STRERROR(result));
 
 			tracker_close_connection_ex(conn, true);
 			continue;
@@ -1438,6 +1444,7 @@ int tracker_get_storage_status(ConnectionInfo *pTrackerServer,
 	bool new_connection;
 	char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
 			IP_ADDRESS_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char *pInBuff;
 	char *p;
 	int result;
@@ -1467,15 +1474,14 @@ int tracker_get_storage_status(ConnectionInfo *pTrackerServer,
 	}
 	pHeader->cmd = TRACKER_PROTO_CMD_STORAGE_GET_STATUS;
 	long2buff(FDFS_GROUP_NAME_MAX_LEN + ip_len, pHeader->pkg_len);
-	if ((result=tcpsenddata_nb(conn->sock, out_buff, \
+	if ((result=tcpsenddata_nb(conn->sock, out_buff,
 			p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to tracker server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pTrackerServer->ip_addr, \
-			pTrackerServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to tracker server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+			pTrackerServer->port, result, STRERROR(result));
 	}
 	else
 	{
@@ -1502,11 +1508,11 @@ int tracker_get_storage_status(ConnectionInfo *pTrackerServer,
 
 	if (in_bytes != sizeof(FDFSStorageBrief))
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u response data " \
-			"length: %"PRId64" is invalid", \
-			__LINE__, pTrackerServer->ip_addr, \
-			pTrackerServer->port, in_bytes);
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u response data "
+			"length: %"PRId64" is invalid", __LINE__,
+            formatted_ip, pTrackerServer->port, in_bytes);
 		return EINVAL;
 	}
 
@@ -1522,6 +1528,7 @@ int tracker_get_storage_id(ConnectionInfo *pTrackerServer, \
 	bool new_connection;
 	char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
 			IP_ADDRESS_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char *p;
 	int result;
 	int ip_len;
@@ -1555,15 +1562,14 @@ int tracker_get_storage_id(ConnectionInfo *pTrackerServer, \
 	}
 	pHeader->cmd = TRACKER_PROTO_CMD_STORAGE_GET_SERVER_ID;
 	long2buff(FDFS_GROUP_NAME_MAX_LEN + ip_len, pHeader->pkg_len);
-	if ((result=tcpsenddata_nb(conn->sock, out_buff, \
+	if ((result=tcpsenddata_nb(conn->sock, out_buff,
 			p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to tracker server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pTrackerServer->ip_addr, \
-			pTrackerServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to tracker server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
+			pTrackerServer->port, result, STRERROR(result));
 	}
 	else
 	{
@@ -1589,10 +1595,10 @@ int tracker_get_storage_id(ConnectionInfo *pTrackerServer, \
 
 	if (in_bytes == 0 || in_bytes >= FDFS_STORAGE_ID_MAX_SIZE)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u response data " \
-			"length: %"PRId64" is invalid", \
-			__LINE__, pTrackerServer->ip_addr, \
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u response data length: %"PRId64" "
+            "is invalid", __LINE__, formatted_ip,
 			pTrackerServer->port, in_bytes);
 		return EINVAL;
 	}
@@ -1654,4 +1660,3 @@ int tracker_get_storage_max_status(TrackerServerGroup *pTrackerGroup, \
 
 	return 0;
 }
-

common/fdfs_global.c

@@ -20,10 +20,11 @@
 #include "fastcommon/logger.h"
 #include "fdfs_global.h"
 
-Version g_fdfs_version = {6, 10, 0};
+Version g_fdfs_version = {6, 12, 2};
 bool g_use_connection_pool = false;
 ConnectionPool g_connection_pool;
 int g_connection_pool_max_idle_time = 3600;
+struct base64_context g_fdfs_base64_context;
 
 /*
 data filename format:

common/fdfs_global.h

@@ -12,9 +12,10 @@
 #define _FDFS_GLOBAL_H
 
 #include "fastcommon/common_define.h"
+#include "fastcommon/base64.h"
+#include "fastcommon/connection_pool.h"
 #include "sf/sf_global.h"
 #include "fdfs_define.h"
-#include "fastcommon/connection_pool.h"
 
 #define FDFS_FILE_EXT_NAME_MAX_LEN	6
 
@@ -26,6 +27,7 @@ extern Version g_fdfs_version;
 extern bool g_use_connection_pool;
 extern ConnectionPool g_connection_pool;
 extern int g_connection_pool_max_idle_time;
+extern struct base64_context g_fdfs_base64_context;
 
 int fdfs_check_data_filename(const char *filename, const int len);
 int fdfs_gen_slave_filename(const char *master_filename, \

conf/client.conf

@@ -16,9 +16,13 @@ base_path = /opt/fastdfs
 #   and the HOST can be dual IPs or hostnames seperated by comma,
 #   the dual IPS must be an inner (intranet) IP and an outer (extranet) IP,
 #   or two different types of inner (intranet) IPs.
+#   IPv4:
 #   for example: 192.168.2.100,122.244.141.46:22122
 #   another eg.: 192.168.1.10,172.17.4.21:22122
-
+#
+#   IPv6:
+#    for example: [2409:8a20:42d:2f40:587a:4c47:72c0:ad8e,fe80::1ee9:90a8:1351:436c]:22122
+#
 tracker_server = 192.168.0.196:22122
 tracker_server = 192.168.0.197:22122
 
@@ -33,6 +37,13 @@ tracker_server = 192.168.0.197:22122
 ### debug
 log_level = info
 
+# connect which ip address first for multi IPs of a storage server, value list:
+## tracker: connect to the ip address return by tracker server first
+## last-connected: connect to the ip address last connected first
+# default value is tracker
+# since V6.11
+connect_first_by = tracker
+
 # if use connection pool
 # default value is false
 # since V4.05

conf/storage.conf

@@ -12,6 +12,15 @@ group_name = group1
 
 # bind an address of this host
 # empty for bind all addresses of this host
+#
+# bind IPv4 example: 192.168.2.100
+#
+# bind IPv6 example: 2409:8a20:42d:2f40:587a:4c47:72c0:ad8e
+#
+# bind IPv4 and IPv6 example: 192.168.2.100,2409:8a20:42d:2f40:587a:4c47:72c0:ad8e
+#
+# as any/all addresses, IPv4 is 0.0.0.0, IPv6 is ::
+#
 bind_addr =
 
 # if bind an address of this host when connect to other servers 
@@ -23,6 +32,27 @@ client_bind = true
 # the storage server port
 port = 23000
 
+# the address family of service, value list:
+##  IPv4: IPv4 stack
+##  IPv6: IPv6 stack
+##  auto: auto detect by bind_addr, IPv4 first then IPv6 when bind_addr is empty
+##  both: IPv4 and IPv6 dual stacks
+# default value is auto
+# since V6.11
+address_family = auto
+
+
+# specify the storage server ID for NAT network
+# NOT set or commented for auto set by the local ip addresses
+# since V6.11
+#
+# NOTE:
+## * this paramter is valid only when use_storage_id and trust_storage_server_id
+##     in tracker.conf set to true
+## * the storage server id must exist in storage_ids.conf
+#server_id =
+
+
 # connect timeout in seconds
 # default value is 30
 # Note: in the intranet network (LAN), 2 seconds is enough.
@@ -139,9 +169,13 @@ subdir_count_per_path = 256
 #   and the HOST can be dual IPs or hostnames seperated by comma,
 #   the dual IPS must be an inner (intranet) IP and an outer (extranet) IP,
 #   or two different types of inner (intranet) IPs.
+#   IPv4:
 #   for example: 192.168.2.100,122.244.141.46:22122
 #   another eg.: 192.168.1.10,172.17.4.21:22122
-
+#
+#   IPv6:
+#    for example: [2409:8a20:42d:2f40:587a:4c47:72c0:ad8e,fe80::1ee9:90a8:1351:436c]:22122
+#
 tracker_server = 192.168.209.121:22122
 tracker_server = 192.168.209.122:22122
 

conf/storage_ids.conf

@@ -6,11 +6,17 @@
 # storage ip or hostname can be dual IPs seperated by comma,
 # one is an inner (intranet) IP and another is an outer (extranet) IP,
 # or two different types of inner (intranet) IPs
+# IPv4:
 # for example: 192.168.2.100,122.244.141.46
 # another eg.: 192.168.1.10,172.17.4.21
 #
+# IPv6:
+# or example: [2409:8a20:42d:2f40:587a:4c47:72c0:ad8e,fe80::1ee9:90a8:1351:436c]
+# another eg.:  [2409:8a20:42d:2f40:587a:4c47:72c0:ad8e,fe80::1ee9:90a8:1351:436c]:100002
+#
 # the port is optional. if you run more than one storaged instances
 # in a server, you must specified the port to distinguish different instances.
 
 100001   group1  192.168.0.196
 100002   group1  192.168.0.197
+100003   group1  [2409:8a20:42d:2f40:587a:4c47:72c0:ad8e]:100002

conf/tracker.conf

@@ -5,11 +5,33 @@ disabled = false
 
 # bind an address of this host
 # empty for bind all addresses of this host
+#
+# bind IPv4 example: 192.168.2.100
+#
+# bind IPv6 example: 2409:8a20:42d:2f40:587a:4c47:72c0:ad8e
+#
+# bind IPv4 and IPv6 example: 192.168.2.100,2409:8a20:42d:2f40:587a:4c47:72c0:ad8e
+#
+# as any/all addresses, IPv4 is 0.0.0.0, IPv6 is ::
+#
 bind_addr =
 
 # the tracker server port
 port = 22122
 
+# the address family of service, value list:
+##  IPv4: IPv4 stack
+##  IPv6: IPv6 stack
+##  auto: auto detect by bind_addr, IPv4 first then IPv6 when bind_addr is empty
+##  both: IPv4 and IPv6 dual stacks
+#
+# following parameter use_storage_id MUST set to true and
+# id_type_in_filename MUST set to id when IPv6 enabled
+#
+# default value is auto
+# since V6.11
+address_family = auto
+
 # connect timeout in seconds
 # default value is 30
 # Note: in the intranet network (LAN), 2 seconds is enough.
@@ -81,7 +103,12 @@ download_server = 0
 ### M or m for megabyte(MB)
 ### K or k for kilobyte(KB)
 ### no unit for byte(B)
+#
 ### XX.XX% as ratio such as: reserved_storage_space = 10%
+#
+# NOTE:
+## the absolute reserved space is the sum of all store paths in the storage server
+## the reserved space ratio is for each store path
 reserved_storage_space = 20%
 
 #standard log level as syslog, case insensitive, value list:
@@ -260,6 +287,13 @@ storage_ids_filename = storage_ids.conf
 # since V4.03
 id_type_in_filename = id
 
+# if trust the storage server ID sent by the storage server
+# this paramter is valid only when use_storage_id set to true
+# default value is true
+# since V6.11
+trust_storage_server_id = true
+
+
 # if store slave file use symbol link
 # default value is false
 # since V4.01

debian/README.Debian

@@ -0,0 +1,5 @@
+FastDFS is an open source high performance distributed file system. Its major
+functions include: file storing, file syncing and file accessing (file uploading
+and file downloading), and it can resolve the high capacity and load balancing
+problem. FastDFS should meet the requirement of the website whose service based
+on files such as photo sharing site and video sharing site.

debian/changelog

@@ -0,0 +1,7 @@
+fastdfs (6.12.1-1) stable; urgency=medium
+
+  * adapt to libserverframe 1.2.3
+  * bugfixed: notify_leader_changed support IPv6 correctly
+  * log square quoted IPv6 address
+
+ -- YuQing <384681@qq.com>  Wed, 6 Mar 2024 15:14:27 +0000

debian/compat

@@ -0,0 +1 @@
+11

debian/control

@@ -0,0 +1,56 @@
+Source: fastdfs
+Section: admin
+Priority: optional
+Maintainer: YuQing <384681@qq.com>
+Build-Depends: debhelper (>=11~),
+               libfastcommon-dev (>= 1.0.73),
+               libserverframe-dev (>= 1.2.3)
+Standards-Version: 4.1.4
+Homepage: http://github.com/happyfish100/fastdfs/
+
+Package: fastdfs
+Architecture: linux-any
+Multi-Arch: foreign
+Depends: fastdfs-server (= ${binary:Version}),
+         fastdfs-tool (= ${binary:Version}),
+         ${misc:Depends}
+Description: FastDFS server and client 
+
+Package: fastdfs-server
+Architecture: linux-any
+Multi-Arch: foreign
+Depends: libfastcommon (>= ${libfastcommon:Version}),
+         libserverframe (>= ${libserverframe:Version}),
+         fastdfs-config (>= ${fastdfs-config:Version}),
+         ${misc:Depends}, ${shlibs:Depends}
+Description: FastDFS server
+
+Package: libfdfsclient
+Architecture: linux-any
+Multi-Arch: foreign
+Depends: libfastcommon (>= ${libfastcommon:Version}),
+         libserverframe (>= ${libserverframe:Version}),
+         ${misc:Depends}, ${shlibs:Depends}
+Description: FastDFS client tools
+
+Package: libfdfsclient-dev
+Architecture: linux-any
+Multi-Arch: foreign
+Depends: libfdfsclient (= ${binary:Version}),
+         ${misc:Depends}
+Description: header files of FastDFS client library
+ This package provides the header files of libfdfsclient
+
+Package: fastdfs-tool
+Architecture: linux-any
+Multi-Arch: foreign
+Depends: libfdfsclient (= ${binary:Version}),
+         fastdfs-config (>= ${fastdfs-config:Version}),
+         ${misc:Depends}, ${shlibs:Depends}
+Description: FastDFS client tools
+
+Package: fastdfs-config
+Architecture: linux-any
+Multi-Arch: foreign
+Description: FastDFS config files for sample
+ FastDFS config files for sample including server and client

debian/copyright

@@ -0,0 +1,675 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+ 
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+  
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+

debian/fastdfs-config.install

@@ -0,0 +1 @@
+etc/fdfs/*.conf

debian/fastdfs-server.dirs

@@ -0,0 +1 @@
+opt/fastdfs

debian/fastdfs-server.install

@@ -0,0 +1,2 @@
+usr/bin/fdfs_trackerd
+usr/bin/fdfs_storaged

debian/fastdfs-tool.dirs

@@ -0,0 +1 @@
+opt/fastdfs

debian/fastdfs-tool.install

@@ -0,0 +1,13 @@
+usr/bin/fdfs_monitor
+usr/bin/fdfs_test
+usr/bin/fdfs_test1
+usr/bin/fdfs_crc32
+usr/bin/fdfs_upload_file
+usr/bin/fdfs_download_file
+usr/bin/fdfs_delete_file
+usr/bin/fdfs_file_info
+usr/bin/fdfs_appender_test
+usr/bin/fdfs_appender_test1
+usr/bin/fdfs_append_file
+usr/bin/fdfs_upload_appender
+usr/bin/fdfs_regenerate_filename

debian/libfdfsclient-dev.install

@@ -0,0 +1 @@
+usr/include/fastdfs/*

debian/libfdfsclient.install

@@ -0,0 +1 @@
+usr/lib/libfdfsclient*

debian/rules

@@ -0,0 +1,30 @@
+#!/usr/bin/make -f
+
+export DH_VERBOSE=1
+export DESTDIR=$(CURDIR)/debian/tmp
+
+export CONFDIR=$(DESTDIR)/etc/fdfs/
+
+%:
+	dh $@
+
+
+override_dh_auto_build:
+	./make.sh clean && DESTDIR=$(DESTDIR) ./make.sh
+
+override_dh_auto_install:
+	DESTDIR=$(DESTDIR) ./make.sh install
+	mkdir -p $(CONFDIR)
+	cp conf/*.conf $(CONFDIR)
+	cp systemd/fdfs_storaged.service debian/fastdfs-server.fdfs_storaged.service
+	cp systemd/fdfs_trackerd.service debian/fastdfs-server.fdfs_trackerd.service
+
+	dh_auto_install
+
+override_dh_installsystemd:
+	dh_installsystemd --package=fastdfs-server --name=fdfs_storaged --no-start --no-restart-on-upgrade
+	dh_installsystemd --package=fastdfs-server --name=fdfs_trackerd --no-start --no-restart-on-upgrade
+
+.PHONY: override_dh_gencontrol
+override_dh_gencontrol:
+	dh_gencontrol -- -Tdebian/substvars

debian/source/format

@@ -0,0 +1 @@
+3.0 (quilt)

debian/substvars

@@ -0,0 +1,3 @@
+libfastcommon:Version=1.0.73
+libserverframe:Version=1.2.3
+fastdfs-config:Version=1.0.0

debian/watch

@@ -0,0 +1,3 @@
+version=3
+opts="mode=git" https://github.com/happyfish100/fastdfs.git \
+   refs/tags/v([\d\.]+) debian uupdate

fastdfs.spec

@@ -7,25 +7,26 @@
 %define CommitVersion %(echo $COMMIT_VERSION)
 
 Name: %{FastDFS}
-Version: 6.10.0
+Version: 6.12.2
 Release: 1%{?dist}
 Summary: FastDFS server and client
 License: GPL
 Group: Arch/Tech
-URL: 	http://perso.orange.fr/sebastien.godard/
-Source: http://perso.orange.fr/sebastien.godard/%{name}-%{version}.tar.gz
+URL: 	https://github.com/happyfish100/fastdfs/
+Source: https://github.com/happyfish100/fastdfs/%{name}-%{version}.tar.gz
 
 BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n) 
-
+BuildRequires: libserverframe-devel >= 1.2.5
 Requires: %__cp %__mv %__chmod %__grep %__mkdir %__install %__id
-BuildRequires: libserverframe-devel >= 1.2.0
+Requires: %{FDFSServer} = %{version}-%{release}
+Requires: %{FDFSTool} = %{version}-%{release}
 
 %description
 This package provides tracker & storage of fastdfs
 commit version: %{CommitVersion}
 
 %package -n %{FDFSServer}
-Requires: libserverframe >= 1.2.0
+Requires: libserverframe >= 1.2.5
 Requires: %{FDFSConfig}
 Summary: fastdfs tracker & storage
 
@@ -34,7 +35,7 @@ Requires: %{FDFSClient}
 Summary: fastdfs tools
 
 %package -n %{FDFSClient}
-Requires: libserverframe >= 1.2.0
+Requires: libserverframe >= 1.2.5
 Requires: %{FDFSConfig}
 Summary: The client dynamic library of fastdfs
 
@@ -84,6 +85,10 @@ DESTDIR=$RPM_BUILD_ROOT ./make.sh install
 
 %files
 
+%post -n %{FDFSServer}
+systemctl enable fdfs_trackerd
+systemctl enable fdfs_storaged
+
 %files -n %{FDFSServer}
 %defattr(-,root,root,-)
 /usr/bin/fdfs_trackerd

make.sh

@@ -6,7 +6,7 @@ TARGET_SYSTEMD_PATH=$DESTDIR/usr/lib/systemd/system
 
 WITH_LINUX_SERVICE=1
 
-DEBUG_FLAG=1
+DEBUG_FLAG=0
 
 export CC=gcc
 CFLAGS='-Wall'
@@ -22,9 +22,9 @@ else
 fi
 
 if [ -f /usr/include/fastcommon/_os_define.h ]; then
-  OS_BITS=$(fgrep OS_BITS /usr/include/fastcommon/_os_define.h | awk '{print $NF;}')
+  OS_BITS=$(grep -F OS_BITS /usr/include/fastcommon/_os_define.h | awk '{print $NF;}')
 elif [ -f /usr/local/include/fastcommon/_os_define.h ]; then
-  OS_BITS=$(fgrep OS_BITS /usr/local/include/fastcommon/_os_define.h | awk '{print $NF;}')
+  OS_BITS=$(grep -F OS_BITS /usr/local/include/fastcommon/_os_define.h | awk '{print $NF;}')
 else
   OS_BITS=64
 fi
@@ -32,7 +32,15 @@ fi
 uname=$(uname)
 
 if [ "$OS_BITS" -eq 64 ]; then
-  if [ "$uname" = "Darwin" ]; then
+  if [ $uname = 'Linux' ]; then
+    osname=$(cat /etc/os-release | grep -w NAME | awk -F '=' '{print $2;}' | \
+            awk -F '"' '{if (NF==3) {print $2} else {print $1}}' | awk '{print $1}')
+    if [ $osname = 'Ubuntu' -o $osname = 'Debian' ]; then
+      LIB_VERSION=lib
+    else
+      LIB_VERSION=lib64
+    fi
+  elif [ "$uname" = "Darwin" ]; then
     LIB_VERSION=lib
   else
     LIB_VERSION=lib64
@@ -105,7 +113,7 @@ elif [ "$uname" = "FreeBSD" ]; then
 fi
 
 if [ $have_pthread -eq 0 ] && [ "$uname" != "Darwin" ]; then
-   /sbin/ldconfig -p | fgrep libpthread.so > /dev/null
+   /sbin/ldconfig -p | grep -F libpthread.so > /dev/null
    if [ $? -eq 0 ]; then
       LIBS="$LIBS -lpthread"
    else

storage/Makefile.in

@@ -12,6 +12,7 @@ SHARED_OBJS = ../common/fdfs_global.o ../tracker/fdfs_shared_func.o \
               storage_sync_func.o storage_service.o storage_sync.o \
               storage_dio.o storage_ip_changed_dealer.o \
               storage_param_getter.o storage_disk_recovery.o \
+              file_id_hashtable.o  \
               trunk_mgr/trunk_mem.o trunk_mgr/trunk_shared.o \
               trunk_mgr/trunk_sync.o trunk_mgr/trunk_client.o \
               trunk_mgr/trunk_free_block_checker.o \

storage/fdfs_storaged.c

@@ -42,6 +42,7 @@
 #include "trunk_mem.h"
 #include "trunk_sync.h"
 #include "trunk_shared.h"
+#include "file_id_hashtable.h"
 
 #ifdef WITH_HTTPD
 #include "storage_httpd.h"
@@ -243,6 +244,13 @@ int main(int argc, char *argv[])
     }
 
     if ((result=setup_schedule_tasks()) != 0)
+    {
+		logCrit("exit abnormally!\n");
+		log_destroy();
+		return result;
+    }
+
+    if ((result=file_id_hashtable_init()) != 0)
     {
 		logCrit("exit abnormally!\n");
 		log_destroy();
@@ -351,14 +359,30 @@ static void sigAlarmHandler(int sig)
 	logDebug("file: "__FILE__", line: %d, " \
 		"signal server to quit...", __LINE__);
 
-	if (*SF_G_INNER_BIND_ADDR != '\0')
-	{
-		strcpy(server.ip_addr, SF_G_INNER_BIND_ADDR);
-	}
-	else
-	{
-		strcpy(server.ip_addr, "127.0.0.1");
-	}
+    if (SF_G_IPV4_ENABLED)
+    {
+        server.af = AF_INET;
+        if (*SF_G_INNER_BIND_ADDR4 != '\0')
+        {
+            strcpy(server.ip_addr, SF_G_INNER_BIND_ADDR4);
+        }
+        else
+        {
+            strcpy(server.ip_addr, LOCAL_LOOPBACK_IPv4);
+        }
+    }
+    else
+    {
+        server.af = AF_INET6;
+        if (*SF_G_INNER_BIND_ADDR6 != '\0')
+        {
+            strcpy(server.ip_addr, SF_G_INNER_BIND_ADDR6);
+        }
+        else
+        {
+            strcpy(server.ip_addr, LOCAL_LOOPBACK_IPv6);
+        }
+    }
 	server.port = SF_G_INNER_PORT;
 	server.sock = -1;
 
@@ -476,9 +500,9 @@ static int setup_schedule_tasks()
 
 	if (g_compress_binlog)
 	{
-		INIT_SCHEDULE_ENTRY_EX(scheduleEntries[scheduleArray.count],
+		INIT_SCHEDULE_ENTRY_EX1(scheduleEntries[scheduleArray.count],
 			sched_generate_next_id(), g_compress_binlog_time,
-			24 * 3600, fdfs_binlog_compress_func, NULL);
+			24 * 3600, fdfs_binlog_compress_func, NULL, true);
 		scheduleArray.count++;
     }
 

storage/fdht_client/fdht_func.c

@@ -22,6 +22,7 @@
 #include <time.h>
 #include "fastcommon/logger.h"
 #include "fastcommon/sockopt.h"
+#include "fastcommon/local_ip_func.h"
 #include "fastcommon/shared_func.h"
 #include "fastcommon/ini_file_reader.h"
 #include "fdht_func.h"
@@ -448,7 +449,7 @@ int fdht_load_groups_ex(IniContext *pIniContext, \
 		pItemEnd = pItemInfo + pServerArray->count;
 		for (; pItemInfo<pItemEnd; pItemInfo++)
 		{
-			if (splitEx(pItemInfo->value, ':', ip_port, 2) != 2)
+			if (parseAddress(pItemInfo->value, ip_port) !=2 )
 			{
 				logError("file: "__FILE__", line: %d, " \
 					"\"%s\" 's value \"%s\" is invalid, "\
@@ -468,12 +469,13 @@ int fdht_load_groups_ex(IniContext *pIniContext, \
 				return EINVAL;
 			}
 
-			if (strcmp(pServerInfo->ip_addr, "127.0.0.1") == 0)
+			if (strcmp(pServerInfo->ip_addr, LOCAL_LOOPBACK_IPv4) == 0 ||
+				strcmp(pServerInfo->ip_addr, LOCAL_LOOPBACK_IPv6) ==0 )
 			{
 				logError("file: "__FILE__", line: %d, " \
 					"group%d: invalid hostname \"%s\", " \
-					"ip address can not be 127.0.0.1!", \
-					__LINE__, group_id, pItemInfo->value);
+					"ip address can not be %s!", \
+					__LINE__, group_id, pItemInfo->value, pServerInfo->ip_addr);
 				return EINVAL;
 			}
 

storage/fdht_client/fdht_proto.c

@@ -172,7 +172,17 @@ int fdht_connect_server_nb(FDHTServerInfo *pServer, const int connect_timeout)
 	{
 		close(pServer->sock);
 	}
-	pServer->sock = socket(AF_INET, SOCK_STREAM, 0);
+
+    // 通过判断IP地址是IPv4或者IPv6，根据结果进行初始化
+    if (is_ipv6_addr(pServer->ip_addr))
+    {
+        pServer->sock = socket(AF_INET6, SOCK_STREAM, 0);
+    }
+    else
+    {
+        pServer->sock = socket(AF_INET, SOCK_STREAM, 0);
+    }
+
 	if(pServer->sock < 0)
 	{
 		logError("file: "__FILE__", line: %d, " \
@@ -213,7 +223,17 @@ int fdht_connect_server(FDHTServerInfo *pServer)
 	{
 		close(pServer->sock);
 	}
-	pServer->sock = socket(AF_INET, SOCK_STREAM, 0);
+
+    // 通过判断IP地址是IPv4或者IPv6，根据结果进行初始化
+    if (is_ipv6_addr(pServer->ip_addr))
+    {
+        pServer->sock = socket(AF_INET6, SOCK_STREAM, 0);
+    }
+    else
+    {
+        pServer->sock = socket(AF_INET, SOCK_STREAM, 0);
+    }
+
 	if(pServer->sock < 0)
 	{
 		logError("file: "__FILE__", line: %d, " \

storage/file_id_hashtable.c

@@ -0,0 +1,335 @@
+/*
+ * Copyright (c) 2020 YuQing <384681@qq.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "fastcommon/pthread_func.h"
+#include "fastcommon/logger.h"
+#include "fastcommon/fc_atomic.h"
+#include "fastcommon/fast_allocator.h"
+#include "file_id_hashtable.h"
+
+typedef struct file_id_info {
+    string_t file_id;
+    uint32_t hash_code;
+    uint32_t expires;
+    struct {
+        struct file_id_info *htable;
+        struct file_id_info *list;
+    } nexts;
+} FileIdInfo;
+
+typedef struct {
+    FileIdInfo **buckets;
+    uint32_t capacity;
+#if defined(DEBUG_FLAG)
+    volatile uint32_t count;
+#endif
+} FileIdHashtable;
+
+typedef struct {
+    pthread_mutex_t *locks;
+    int count;
+} FileIdSharedLockArray;
+
+typedef struct {
+    struct {
+        struct file_id_info *head;
+        struct file_id_info *tail;
+        pthread_mutex_t lock;
+    } list;
+    FileIdHashtable htable;
+    FileIdSharedLockArray lock_array;
+    struct fast_mblock_man allocator;  //element: FileIdInfo
+    struct fast_allocator_context acontext; //for string allocator
+} FileIdHTableContext;
+
+static FileIdHTableContext file_id_ctx = {
+    {NULL, NULL}, {NULL, 0}, {NULL, 0}
+};
+
+static int clear_expired_file_id_func(void *args);
+
+int file_id_hashtable_init()
+{
+    const int obj_size = 0;
+    int result;
+    int bytes;
+    struct fast_region_info regions[2];
+    pthread_mutex_t *lock;
+    pthread_mutex_t *end;
+    ScheduleArray scheduleArray;
+    ScheduleEntry entry;
+
+    file_id_ctx.htable.capacity = 1403641;
+    bytes = sizeof(FileIdInfo *) * file_id_ctx.htable.capacity;
+    file_id_ctx.htable.buckets = fc_malloc(bytes);
+    if (file_id_ctx.htable.buckets == NULL) {
+        return ENOMEM;
+    }
+    memset(file_id_ctx.htable.buckets, 0, bytes);
+
+    file_id_ctx.lock_array.count = 163;
+    bytes = sizeof(pthread_mutex_t) * file_id_ctx.lock_array.count;
+    file_id_ctx.lock_array.locks = fc_malloc(bytes);
+    if (file_id_ctx.lock_array.locks == NULL) {
+        return ENOMEM;
+    }
+
+    end = file_id_ctx.lock_array.locks + file_id_ctx.lock_array.count;
+    for (lock=file_id_ctx.lock_array.locks; lock<end; lock++) {
+        if ((result=init_pthread_lock(lock)) != 0) {
+            return result;
+        }
+    }
+
+    if ((result=init_pthread_lock(&file_id_ctx.list.lock)) != 0) {
+        return result;
+    }
+
+    if ((result=fast_mblock_init_ex1(&file_id_ctx.allocator,
+                    "file-id", sizeof(FileIdInfo), 16 * 1024,
+                    0, NULL, NULL, true)) != 0)
+    {
+        return result;
+    }
+
+    FAST_ALLOCATOR_INIT_REGION(regions[0],  0,  48, 48, 16 * 1024);
+    FAST_ALLOCATOR_INIT_REGION(regions[1], 48, 128,  8,  8 * 1024);
+    if ((result=fast_allocator_init_ex(&file_id_ctx.acontext, "file-id",
+                    obj_size, NULL, regions, 2, 0, 0.00, 0, true)) != 0)
+    {
+        return result;
+    }
+
+    INIT_SCHEDULE_ENTRY(entry, FDFS_CLEAR_EXPIRED_FILE_ID_TASK_ID,
+            0, 0, 0, 1, clear_expired_file_id_func, NULL);
+    scheduleArray.count = 1;
+    scheduleArray.entries = &entry;
+    return sched_add_entries(&scheduleArray);
+}
+
+void file_id_hashtable_destroy()
+{
+    if (file_id_ctx.htable.buckets != NULL) {
+        free(file_id_ctx.htable.buckets);
+        file_id_ctx.htable.buckets = NULL;
+    }
+
+    if (file_id_ctx.lock_array.locks != NULL) {
+        pthread_mutex_t *lock;
+        pthread_mutex_t *end;
+
+        end = file_id_ctx.lock_array.locks +
+            file_id_ctx.lock_array.count;
+        for (lock=file_id_ctx.lock_array.locks; lock<end; lock++) {
+            pthread_mutex_destroy(lock);
+        }
+
+        free(file_id_ctx.lock_array.locks);
+        file_id_ctx.lock_array.locks = NULL;
+    }
+
+    fast_mblock_destroy(&file_id_ctx.allocator);
+    pthread_mutex_destroy(&file_id_ctx.list.lock);
+    fast_allocator_destroy(&file_id_ctx.acontext);
+}
+
+#define FILE_ID_HASHTABLE_DECLARE_VARS() \
+    uint32_t bucket_index;  \
+    FileIdInfo **bucket;    \
+    pthread_mutex_t *lock
+
+#define FILE_ID_HASHTABLE_SET_BUCKET_AND_LOCK(hash_code) \
+    bucket_index = hash_code % file_id_ctx.htable.capacity; \
+    bucket = file_id_ctx.htable.buckets + bucket_index;    \
+    lock = file_id_ctx.lock_array.locks + bucket_index %   \
+        file_id_ctx.lock_array.count
+
+int file_id_hashtable_add(const string_t *file_id)
+{
+    int result;
+    uint32_t hash_code;
+    FileIdInfo *current;
+    FileIdInfo *previous;
+    FileIdInfo *finfo;
+    FILE_ID_HASHTABLE_DECLARE_VARS();
+
+    hash_code = fc_simple_hash(file_id->str, file_id->len);
+    FILE_ID_HASHTABLE_SET_BUCKET_AND_LOCK(hash_code);
+
+    result = 0;
+    PTHREAD_MUTEX_LOCK(lock);
+    previous = NULL;
+    current = *bucket;
+    while (current != NULL) {
+        if (hash_code < current->hash_code) {
+            break;
+        } else if (hash_code == current->hash_code && fc_string_equal(
+                    file_id, &current->file_id))
+        {
+            result = EEXIST;
+            break;
+        }
+
+        previous = current;
+        current = current->nexts.htable;
+    }
+
+    if (result == 0) {
+        do {
+            if ((finfo=fast_mblock_alloc_object(&file_id_ctx.
+                            allocator)) == NULL)
+            {
+                result = ENOMEM;
+                break;
+            }
+            if ((finfo->file_id.str=fast_allocator_alloc(&file_id_ctx.
+                            acontext, file_id->len)) == NULL)
+            {
+                fast_mblock_free_object(&file_id_ctx.allocator, finfo);
+                result = ENOMEM;
+                break;
+            }
+
+            memcpy(finfo->file_id.str, file_id->str, file_id->len);
+            finfo->file_id.len = file_id->len;
+            finfo->hash_code = hash_code;
+            finfo->expires = g_current_time + 3;
+            if (previous == NULL) {
+                finfo->nexts.htable = *bucket;
+                *bucket = finfo;
+            } else {
+                finfo->nexts.htable = current;
+                previous->nexts.htable = finfo;
+            }
+
+#if defined(DEBUG_FLAG)
+            FC_ATOMIC_INC(file_id_ctx.htable.count);
+#endif
+
+        } while (0);
+    } else {
+        finfo = NULL;
+    }
+    PTHREAD_MUTEX_UNLOCK(lock);
+
+    if (result == 0) {
+        PTHREAD_MUTEX_LOCK(&file_id_ctx.list.lock);
+        finfo->nexts.list = NULL;
+        if (file_id_ctx.list.tail == NULL) {
+            file_id_ctx.list.head = finfo;
+        } else {
+            file_id_ctx.list.tail->nexts.list = finfo;
+        }
+        file_id_ctx.list.tail = finfo;
+        PTHREAD_MUTEX_UNLOCK(&file_id_ctx.list.lock);
+    }
+    return result;
+}
+
+static int file_id_hashtable_del(FileIdInfo *finfo)
+{
+    int result;
+    FileIdInfo *current;
+    FileIdInfo *previous;
+    FILE_ID_HASHTABLE_DECLARE_VARS();
+
+    FILE_ID_HASHTABLE_SET_BUCKET_AND_LOCK(finfo->hash_code);
+    PTHREAD_MUTEX_LOCK(lock);
+    if (*bucket == NULL) {
+        result = ENOENT;
+    } else if (finfo->hash_code == (*bucket)->hash_code &&
+            fc_string_equal(&finfo->file_id, &(*bucket)->file_id))
+    {
+        *bucket = (*bucket)->nexts.htable;
+#if defined(DEBUG_FLAG)
+        FC_ATOMIC_DEC(file_id_ctx.htable.count);
+#endif
+        result = 0;
+    } else {
+        result = ENOENT;
+        previous = *bucket;
+        while ((current=previous->nexts.htable) != NULL) {
+            if (finfo->hash_code < current->hash_code) {
+                break;
+            } else if (finfo->hash_code == current->hash_code &&
+                    fc_string_equal(&finfo->file_id, &current->file_id))
+            {
+                previous->nexts.htable = current->nexts.htable;
+#if defined(DEBUG_FLAG)
+                FC_ATOMIC_DEC(file_id_ctx.htable.count);
+#endif
+                result = 0;
+                break;
+            }
+
+            previous = current;
+        }
+    }
+    PTHREAD_MUTEX_UNLOCK(lock);
+
+    return result;
+}
+
+static int clear_expired_file_id_func(void *args)
+{
+    struct file_id_info *head;
+    struct file_id_info *tail;
+    struct fast_mblock_chain chain;
+    struct fast_mblock_node *node;
+
+    head = tail = NULL;
+    PTHREAD_MUTEX_LOCK(&file_id_ctx.list.lock);
+    if (file_id_ctx.list.head != NULL && file_id_ctx.
+            list.head->expires < g_current_time)
+    {
+        head = tail = file_id_ctx.list.head;
+        file_id_ctx.list.head = file_id_ctx.list.head->nexts.list;
+        while (file_id_ctx.list.head != NULL && file_id_ctx.
+                list.head->expires < g_current_time)
+        {
+            tail = file_id_ctx.list.head;
+            file_id_ctx.list.head = file_id_ctx.list.head->nexts.list;
+        }
+
+        if (file_id_ctx.list.head == NULL) {
+            file_id_ctx.list.tail = NULL;
+        } else {
+            tail->nexts.list = NULL;
+        }
+    }
+    PTHREAD_MUTEX_UNLOCK(&file_id_ctx.list.lock);
+
+    if (head == NULL) {
+        return 0;
+    }
+
+    chain.head = chain.tail = NULL;
+    do {
+        node = fast_mblock_to_node_ptr(head);
+        if (chain.head == NULL) {
+            chain.head = node;
+        } else {
+            chain.tail->next = node;
+        }
+        chain.tail = node;
+
+        file_id_hashtable_del(head);
+        fast_allocator_free(&file_id_ctx.acontext, head->file_id.str);
+    } while ((head=head->nexts.list) != NULL);
+
+    chain.tail->next = NULL;
+    fast_mblock_batch_free(&file_id_ctx.allocator, &chain);
+    return 0;
+}

storage/file_id_hashtable.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2020 YuQing <384681@qq.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef _FILE_ID_HASHTABLE_H
+#define _FILE_ID_HASHTABLE_H
+
+#include "storage_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    int file_id_hashtable_init();
+
+    void file_id_hashtable_destroy();
+
+    int file_id_hashtable_add(const string_t *file_id);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

storage/storage_disk_recovery.c

@@ -119,6 +119,7 @@ static int storage_do_fetch_binlog(ConnectionInfo *pSrcStorage, \
 {
 	char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + 1];
 	char full_binlog_filename[MAX_PATH_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	TrackerHeader *pHeader;
 	char *pBasePath;
 	int64_t in_bytes;
@@ -142,10 +143,11 @@ static int storage_do_fetch_binlog(ConnectionInfo *pSrcStorage, \
 	if((result=tcpsenddata_nb(pSrcStorage->sock, out_buff,
 		sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
 	{
+        format_ip_address(pSrcStorage->ip_addr, formatted_ip);
 		logError("file: "__FILE__", line: %d, "
 			"storage server %s:%u, send data fail, "
-			"errno: %d, error info: %s.",
-			__LINE__, pSrcStorage->ip_addr, pSrcStorage->port,
+			"errno: %d, error info: %s.", __LINE__,
+            formatted_ip, pSrcStorage->port,
 			result, STRERROR(result));
 		return result;
 	}
@@ -170,17 +172,19 @@ static int storage_do_fetch_binlog(ConnectionInfo *pSrcStorage, \
 	if ((result=tcprecvfile(pSrcStorage->sock, full_binlog_filename,
 				in_bytes, 0, network_timeout, &file_bytes)) != 0)
 	{
+        format_ip_address(pSrcStorage->ip_addr, formatted_ip);
 		logError("file: "__FILE__", line: %d, "
 			"storage server %s:%u, tcprecvfile fail, "
-			"errno: %d, error info: %s.",
-			__LINE__, pSrcStorage->ip_addr, pSrcStorage->port,
+			"errno: %d, error info: %s.", __LINE__,
+            formatted_ip, pSrcStorage->port,
 			result, STRERROR(result));
 		return result;
 	}
 
+    format_ip_address(pSrcStorage->ip_addr, formatted_ip);
 	logInfo("file: "__FILE__", line: %d, "
 		"recovery binlog from %s:%u, file size: %"PRId64, __LINE__,
-        pSrcStorage->ip_addr, pSrcStorage->port, file_bytes);
+        formatted_ip, pSrcStorage->port, file_bytes);
 
 	return 0;
 }
@@ -196,6 +200,7 @@ static int recovery_get_src_storage_server(ConnectionInfo *pSrcStorage)
 	FDFSGroupStat groupStat;
 	FDFSStorageInfo storageStats[FDFS_MAX_SERVERS_EACH_GROUP];
 	FDFSStorageInfo *pStorageStat;
+    char formatted_ip[FORMATTED_IP_SIZE];
     bool found;
 
 	memset(pSrcStorage, 0, sizeof(ConnectionInfo));
@@ -356,9 +361,12 @@ static int recovery_get_src_storage_server(ConnectionInfo *pSrcStorage)
 		return EINTR;
 	}
 
-	logDebug("file: "__FILE__", line: %d, "
-		"disk recovery: get source storage server %s:%u",
-		__LINE__, pSrcStorage->ip_addr, pSrcStorage->port);
+    if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
+        format_ip_address(pSrcStorage->ip_addr, formatted_ip);
+        logDebug("file: "__FILE__", line: %d, "
+                "disk recovery: get source storage server %s:%u",
+                __LINE__, formatted_ip, pSrcStorage->port);
+    }
 	return 0;
 }
 
@@ -721,6 +729,7 @@ static int storage_do_recovery(RecoveryThreadData *pThreadData,
 	bool bContinueFlag;
 	char local_filename[MAX_PATH_SIZE];
 	char src_filename[MAX_PATH_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 
 	pTrackerServer = tracker_get_connection_r(&trackerServer, &result);
     if (pTrackerServer == NULL)
@@ -737,10 +746,11 @@ static int storage_do_recovery(RecoveryThreadData *pThreadData,
     noent_count = 0;
 	result = 0;
 
+    format_ip_address(pSrcStorage->ip_addr, formatted_ip);
 	logInfo("file: "__FILE__", line: %d, "
 		"disk recovery thread #%d, src storage server %s:%u, "
         "recovering files of data path: %s ...", __LINE__,
-        pThreadData->thread_index, pSrcStorage->ip_addr,
+        pThreadData->thread_index, formatted_ip,
         pSrcStorage->port, pThreadData->base_path);
 
 	bContinueFlag = true;
@@ -924,10 +934,11 @@ static int storage_do_recovery(RecoveryThreadData *pThreadData,
 
 	if (pThreadData->done)
 	{
+        format_ip_address(pSrcStorage->ip_addr, formatted_ip);
 		logInfo("file: "__FILE__", line: %d, "
 			"disk recovery thread #%d, src storage server %s:%u, "
             "recover files of data path: %s done", __LINE__,
-            pThreadData->thread_index, pSrcStorage->ip_addr,
+            pThreadData->thread_index, formatted_ip,
             pSrcStorage->port, pThreadData->base_path);
 	}
 
@@ -1700,10 +1711,11 @@ static int storage_disk_recovery_split_trunk_binlog(const int store_path_index)
 
 int storage_disk_recovery_prepare(const int store_path_index)
 {
+    char formatted_ip[FORMATTED_IP_SIZE];
 	ConnectionInfo srcStorage;
 	ConnectionInfo *pStorageConn;
-	int result;
 	char *pBasePath;
+	int result;
 
 	pBasePath = g_fdfs_store_paths.paths[store_path_index].path;
 	if ((result=recovery_init_flag_file(pBasePath, false, -1)) != 0)
@@ -1748,9 +1760,10 @@ int storage_disk_recovery_prepare(const int store_path_index)
 		return result;
 	}
 
+    format_ip_address(pStorageConn->ip_addr, formatted_ip);
 	logInfo("file: "__FILE__", line: %d, "
             "try to fetch binlog from %s:%u ...", __LINE__,
-            pStorageConn->ip_addr, pStorageConn->port);
+            formatted_ip, pStorageConn->port);
 
 	result = storage_do_fetch_binlog(pStorageConn, store_path_index);
 	tracker_close_connection_ex(pStorageConn, true);
@@ -1759,9 +1772,10 @@ int storage_disk_recovery_prepare(const int store_path_index)
 		return result;
 	}
 
+    format_ip_address(pStorageConn->ip_addr, formatted_ip);
     logInfo("file: "__FILE__", line: %d, "
             "fetch binlog from %s:%u successfully.", __LINE__,
-            pStorageConn->ip_addr, pStorageConn->port);
+            formatted_ip, pStorageConn->port);
 
 	if ((result=storage_disk_recovery_split_trunk_binlog(
 			store_path_index)) != 0)

storage/storage_dump.c

@@ -32,6 +32,7 @@ static int fdfs_dump_global_vars(char *buff, const int buffSize)
 	char reserved_space_str[32];
     char tracker_client_ip_str[256];
     char last_storage_ip_str[256];
+    char formatted_ip[FORMATTED_IP_SIZE];
     char *p;
 	int total_len;
 	int i;
@@ -40,6 +41,7 @@ static int fdfs_dump_global_vars(char *buff, const int buffSize)
             tracker_client_ip_str, sizeof(tracker_client_ip_str));
     fdfs_multi_ips_to_string(&g_last_storage_ip,
             last_storage_ip_str, sizeof(last_storage_ip_str));
+    format_ip_address(g_trunk_server.connections[0].ip_addr, formatted_ip);
 
 	total_len = snprintf(buff, buffSize,
 		"SF_G_CONNECT_TIMEOUT=%ds\n"
@@ -49,7 +51,7 @@ static int fdfs_dump_global_vars(char *buff, const int buffSize)
 		"SF_G_CONTINUE_FLAG=%d\n"
 		"g_schedule_flag=%d\n"
 		"SF_G_INNER_PORT=%d\n"
-		"g_max_connections=%d\n"
+		"SF_G_MAX_CONNECTIONS=%d\n"
 		"g_storage_thread_count=%d\n"
 		"g_group_name=%s\n"
 		"g_subdir_count_per_path=%d\n"
@@ -93,7 +95,8 @@ static int fdfs_dump_global_vars(char *buff, const int buffSize)
 		"g_check_file_duplicate=%d\n"
 		"g_key_namespace=%s\n"
 		"g_namespace_len=%d\n"
-		"SF_G_INNER_BIND_ADDR=%s\n"
+		"bind_addr_ipv4=%s\n"
+		"bind_addr_ipv6=%s\n"
 		"g_client_bind_addr=%d\n"
 		"g_storage_ip_changed_auto_adjust=%d\n"
 		"g_thread_kill_done=%d\n"
@@ -142,7 +145,7 @@ static int fdfs_dump_global_vars(char *buff, const int buffSize)
         , g_fdfs_version.patch, SF_G_CONTINUE_FLAG
 		, g_schedule_flag
 		, SF_G_INNER_PORT
-		, g_sf_global_vars.max_connections
+		, SF_G_MAX_CONNECTIONS
 		, SF_G_ALIVE_THREAD_COUNT 
 		, g_group_name
 		, g_subdir_count_per_path 
@@ -188,7 +191,8 @@ static int fdfs_dump_global_vars(char *buff, const int buffSize)
 		, g_check_file_duplicate
 		, g_key_namespace
 		, g_namespace_len
-		, SF_G_INNER_BIND_ADDR
+		, SF_G_INNER_BIND_ADDR4
+		, SF_G_INNER_BIND_ADDR6
 		, g_client_bind_addr
 		, g_storage_ip_changed_auto_adjust
 		, g_thread_kill_done
@@ -206,18 +210,18 @@ static int fdfs_dump_global_vars(char *buff, const int buffSize)
 		, g_slot_min_size
 		, g_trunk_file_size
 		, g_store_path_mode
-		, fdfs_storage_reserved_space_to_string( \
-			&g_storage_reserved_space, reserved_space_str) \
+		, fdfs_storage_reserved_space_to_string(
+			&g_storage_reserved_space, reserved_space_str)
 		, g_avg_storage_reserved_mb
 		, g_store_path_index
 		, g_current_trunk_file_id
 		, g_trunk_sync_thread_count
-		, g_trunk_server.connections[0].ip_addr
+        , formatted_ip
         , g_trunk_server.connections[0].port
 		, g_trunk_total_free_space
 		, g_use_connection_pool
 		, g_connection_pool_max_idle_time
-		, g_use_connection_pool ? conn_pool_get_connection_count( \
+		, g_use_connection_pool ? conn_pool_get_connection_count(
 			&g_connection_pool) : 0
 	#ifdef WITH_HTTPD
 		, g_http_params.disabled
@@ -270,6 +274,7 @@ static int fdfs_dump_tracker_servers(char *buff, const int buffSize)
 	int total_len;
 	TrackerServerInfo *pTrackerServer;
 	TrackerServerInfo *pTrackerEnd;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
 	total_len = snprintf(buff, buffSize, \
 		"\ng_tracker_group.server_count=%d, " \
@@ -285,11 +290,12 @@ static int fdfs_dump_tracker_servers(char *buff, const int buffSize)
 	for (pTrackerServer=g_tracker_group.servers; \
 		pTrackerServer<pTrackerEnd; pTrackerServer++)
 	{
+        format_ip_address(pTrackerServer->connections[0].
+                ip_addr, formatted_ip);
 		total_len += snprintf(buff + total_len, buffSize - total_len,
 			"\t%d. tracker server=%s:%u\n",
 			(int)(pTrackerServer - g_tracker_group.servers) + 1,
-			pTrackerServer->connections[0].ip_addr,
-            pTrackerServer->connections[0].port);
+            formatted_ip, pTrackerServer->connections[0].port);
 	}
 
 	return total_len;

storage/storage_func.c

@@ -141,6 +141,7 @@ static int storage_check_and_make_data_dirs();
 static int storage_do_get_group_name(ConnectionInfo *pTrackerServer)
 {
 	char out_buff[sizeof(TrackerHeader) + 4];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	TrackerHeader *pHeader;
 	char *pInBuff;
 	int64_t in_bytes;
@@ -154,12 +155,11 @@ static int storage_do_get_group_name(ConnectionInfo *pTrackerServer)
 	if ((result=tcpsenddata_nb(pTrackerServer->sock, out_buff, \
 			sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u, send data fail, " \
-			"errno: %d, error info: %s.", \
-			__LINE__, pTrackerServer->ip_addr, \
-			pTrackerServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u, send data fail, errno: %d, "
+			"error info: %s.", __LINE__, formatted_ip,
+			pTrackerServer->port, result, STRERROR(result));
 		return result;
 	}
 
@@ -175,11 +175,11 @@ static int storage_do_get_group_name(ConnectionInfo *pTrackerServer)
 
 	if (in_bytes != FDFS_GROUP_NAME_MAX_LEN)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u, recv body length: " \
-			"%"PRId64" != %d",  \
-			__LINE__, pTrackerServer->ip_addr, \
-			pTrackerServer->port, in_bytes, FDFS_GROUP_NAME_MAX_LEN);
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u, recv body length: %"PRId64" != %d",
+            __LINE__, formatted_ip, pTrackerServer->port,
+            in_bytes, FDFS_GROUP_NAME_MAX_LEN);
 		return EINVAL;
 	}
 
@@ -219,42 +219,97 @@ static int storage_get_group_name_from_tracker()
 	return result;
 }
 
-static int tracker_get_my_server_id()
+static int get_my_server_id_by_local_ip()
 {
-	struct in_addr ip_addr;
-    char ip_str[256];
+    FDFSStorageIdInfo *idInfo;
+    const char *ip_addr;
 
-	if (inet_pton(AF_INET, g_tracker_client_ip.ips[0].address, &ip_addr) == 1)
+    ip_addr = get_first_local_ip();
+    while (ip_addr != NULL) {
+        if ((idInfo=fdfs_get_storage_id_by_ip(g_group_name,
+                        ip_addr)) != NULL)
+        {
+            snprintf(g_my_server_id_str, sizeof(g_my_server_id_str),
+                    "%s", idInfo->id);
+            return 0;
+        }
+
+        ip_addr = get_next_local_ip(ip_addr);
+    }
+
+    logError("file: "__FILE__", line: %d, "
+            "can't find my server id by local ip address, "
+            "local ip count: %d", __LINE__, g_local_host_ip_count);
+    return ENOENT;
+}
+
+static int tracker_get_my_server_id(const char *conf_filename,
+        const char *server_id_in_conf)
+{
+	struct in_addr ipv4_addr;
+	struct in6_addr ipv6_addr;
+    char ip_str[256];
+	bool flag = false;
+
+	if (inet_pton(AF_INET, g_tracker_client_ip.ips[0].
+                address, &ipv4_addr) == 1)
 	{
-		g_server_id_in_filename = ip_addr.s_addr;
-	}
-	else
-	{
-		logError("file: "__FILE__", line: %d, " \
-			"call inet_pton for ip: %s fail", \
-		__LINE__, g_tracker_client_ip.ips[0].address);
-		g_server_id_in_filename = INADDR_NONE;
+		g_server_id_in_filename = ipv4_addr.s_addr;
+		flag = true;
 	}
+	else if (inet_pton(AF_INET6, g_tracker_client_ip.ips[0].
+                address, &ipv6_addr) == 1)
+    {
+        g_server_id_in_filename = *((in_addr_64_t *)((char *)&ipv6_addr + 8));
+        flag = true;
+    }
+
+	if (!flag)
+    {
+        logWarning("file: "__FILE__", line: %d, "
+                "call inet_pton for ip: %s fail",
+                __LINE__, g_tracker_client_ip.ips[0].address);
+        g_server_id_in_filename = INADDR_NONE;
+    }
 
 	if (g_use_storage_id)
 	{
 		ConnectionInfo *pTrackerServer;
 		int result;
 
-		pTrackerServer = tracker_get_connection();
-		if (pTrackerServer == NULL)
-		{
-			return errno != 0 ? errno : ECONNREFUSED;
-		}
+        if (g_trust_storage_server_id) {
+            if (server_id_in_conf == NULL) {
+                if ((result=get_my_server_id_by_local_ip()) != 0) {
+                    return result;
+                }
+            } else if (*server_id_in_conf != '\0') {
+                if (!fdfs_is_server_id_valid(server_id_in_conf)) {
+                    logError("file: "__FILE__", line: %d, "
+                            "config file: %s, server_id: %s is invalid",
+                            __LINE__, conf_filename, server_id_in_conf);
+                    return EINVAL;
+                }
+                snprintf(g_my_server_id_str, sizeof(g_my_server_id_str),
+                        "%s", server_id_in_conf);
+            }
+        }
 
-		result = tracker_get_storage_id(pTrackerServer,
-			g_group_name, g_tracker_client_ip.ips[0].address,
-            g_my_server_id_str);
-		tracker_close_connection_ex(pTrackerServer, result != 0);
-		if (result != 0)
-		{
-			return result;
-		}
+        if (*g_my_server_id_str == '\0') {
+            pTrackerServer = tracker_get_connection();
+            if (pTrackerServer == NULL)
+            {
+                return errno != 0 ? errno : ECONNREFUSED;
+            }
+
+            result = tracker_get_storage_id(pTrackerServer,
+                    g_group_name, g_tracker_client_ip.ips[0].address,
+                    g_my_server_id_str);
+            tracker_close_connection_ex(pTrackerServer, result != 0);
+            if (result != 0)
+            {
+                return result;
+            }
+        }
 
 		if (g_id_type_in_filename == FDFS_ID_TYPE_SERVER_ID)
 		{
@@ -262,16 +317,25 @@ static int tracker_get_my_server_id()
 		}
 	}
 	else
-	{
-		snprintf(g_my_server_id_str, sizeof(g_my_server_id_str), "%s",
-			g_tracker_client_ip.ips[0].address);
-	}
+    {
+        // 当IP地址为IPv6时，其storage_id值为IP地址的short code
+        if (is_ipv6_addr(g_tracker_client_ip.ips[0].address))
+        {
+            fdfs_ip_to_shortcode(g_tracker_client_ip.ips[0].address,
+                    g_my_server_id_str);
+        }
+        else
+        {
+            snprintf(g_my_server_id_str, sizeof(g_my_server_id_str), "%s",
+                    g_tracker_client_ip.ips[0].address);
+        }
+    }
 
     fdfs_multi_ips_to_string(&g_tracker_client_ip,
             ip_str, sizeof(ip_str));
 	logInfo("file: "__FILE__", line: %d, "
 		"tracker_client_ip: %s, my_server_id_str: %s, "
-		"g_server_id_in_filename: %d", __LINE__,
+		"g_server_id_in_filename: %"PRIu64, __LINE__,
 		ip_str, g_my_server_id_str, g_server_id_in_filename);
 	return 0;
 }
@@ -1346,6 +1410,7 @@ static int storage_check_tracker_ipaddr(const char *filename)
     TrackerServerInfo *pEnd;
 	ConnectionInfo *conn;
 	ConnectionInfo *conn_end;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
     pEnd = g_tracker_group.servers + g_tracker_group.server_count;
     for (pServer=g_tracker_group.servers; pServer<pEnd; pServer++)
@@ -1353,13 +1418,13 @@ static int storage_check_tracker_ipaddr(const char *filename)
         conn_end = pServer->connections + pServer->count;
         for (conn=pServer->connections; conn<conn_end; conn++)
         {
-            //logInfo("server=%s:%u\n", conn->ip_addr, conn->port);
-            if (strcmp(conn->ip_addr, "127.0.0.1") == 0)
+            if (is_loopback_ip(conn->ip_addr))
             {
+                format_ip_address(conn->ip_addr, formatted_ip);
                 logError("file: "__FILE__", line: %d, "
                         "conf file \"%s\", tracker: \"%s:%u\" is invalid, "
-                        "tracker server ip can't be 127.0.0.1",
-                        __LINE__, filename, conn->ip_addr, conn->port);
+                        "tracker server ip can't be loopback address",
+                        __LINE__, filename, formatted_ip, conn->port);
                 return EINVAL;
             }
         }
@@ -1411,6 +1476,7 @@ int storage_func_init(const char *filename)
 	char *pIfAliasPrefix;
 	char *pHttpDomain;
 	char *pRotateAccessLogSize;
+    char *server_id_in_conf;
 	IniContext iniContext;
     SFContextIniConfig config;
 	int result;
@@ -1443,7 +1509,7 @@ int storage_func_init(const char *filename)
         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");
+                "buff_size", 0);
         if ((result=sf_load_config_ex("storaged", &config, fixed_buffer_size,
                         task_buffer_extra_size, need_set_run_by)) != 0)
         {
@@ -1603,12 +1669,12 @@ int storage_func_init(const char *filename)
 				(g_sync_end_time.hour == 23 && \
 				g_sync_end_time.minute == 59));
 
-        if (g_sf_global_vars.min_buff_size < sizeof(TrackerHeader) +
-                TRUNK_BINLOG_BUFFER_SIZE)
+        if (g_sf_global_vars.net_buffer_cfg.min_buff_size <
+                sizeof(TrackerHeader) + TRUNK_BINLOG_BUFFER_SIZE)
         {
             logError("file: "__FILE__", line: %d, "
                     "item \"buff_size\" is too small, value: %d < %d!",
-                    __LINE__, g_sf_global_vars.min_buff_size,
+                    __LINE__, g_sf_global_vars.net_buffer_cfg.min_buff_size,
                     (int)sizeof(TrackerHeader) + TRUNK_BINLOG_BUFFER_SIZE);
             result = EINVAL;
             break;
@@ -1929,6 +1995,9 @@ int storage_func_init(const char *filename)
 			break;
 		}
 
+        server_id_in_conf = iniGetStrValue(NULL,
+                "server_id", &iniContext);
+
 #ifdef WITH_HTTPD
 		{
 		char *pHttpTrunkSize;
@@ -2077,7 +2146,16 @@ int storage_func_init(const char *filename)
 		return result;
 	}
 
-	if ((result=tracker_get_my_server_id()) != 0)
+	if (g_use_storage_id)
+    {
+        if ((result=fdfs_get_storage_ids_from_tracker_group(
+                        &g_tracker_group)) != 0)
+        {
+            return result;
+        }
+    }
+
+	if ((result=tracker_get_my_server_id(filename, server_id_in_conf)) != 0)
 	{
 		logCrit("file: "__FILE__", line: %d, " \
 			"get my server id from tracker server fail, " \
@@ -2086,15 +2164,6 @@ int storage_func_init(const char *filename)
 		return result;
 	}
 
-	if (g_use_storage_id)
-	{
-		if ((result=fdfs_get_storage_ids_from_tracker_group( \
-				&g_tracker_group)) != 0)
-		{
-			return result;
-		}
-	}
-
 	if ((result=storage_check_ip_changed()) != 0)
 	{
 		return result;
@@ -2188,6 +2257,7 @@ static int storage_get_my_ip_from_tracker(ConnectionInfo *conn,
         char *ip_addrs, const int buff_size)
 {
 	char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	TrackerHeader *pHeader;
 	int result;
     int64_t in_bytes;
@@ -2201,21 +2271,21 @@ static int storage_get_my_ip_from_tracker(ConnectionInfo *conn,
 	if((result=tcpsenddata_nb(conn->sock, out_buff,
 		sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
 	{
+        format_ip_address(conn->ip_addr, formatted_ip);
 		logError("file: "__FILE__", line: %d, "
-			"tracker server %s:%u, send data fail, "
-			"errno: %d, error info: %s.",
-			__LINE__, conn->ip_addr, conn->port,
-			result, STRERROR(result));
+			"tracker server %s:%u, send data fail, errno: %d, "
+			"error info: %s.", __LINE__, formatted_ip,
+            conn->port, result, STRERROR(result));
 		return result;
 	}
 
     if ((result=fdfs_recv_response(conn, &ip_addrs,
                     buff_size - 1, &in_bytes)) != 0)
     {
+        format_ip_address(conn->ip_addr, formatted_ip);
 		logError("file: "__FILE__", line: %d, "
-			"tracker server %s:%u, recv response fail, "
-			"errno: %d, error info: %s.",
-			__LINE__, conn->ip_addr, conn->port,
+			"tracker server %s:%u, recv response fail, errno: %d, "
+			"error info: %s.", __LINE__, formatted_ip, conn->port,
 			result, STRERROR(result));
 		return result;
     }
@@ -2229,6 +2299,7 @@ int storage_set_tracker_client_ips(ConnectionInfo *conn,
 {
     char my_ip_addrs[256];
     char error_info[256];
+    char formatted_ip[FORMATTED_IP_SIZE];
     FDFSMultiIP multi_ip;
 	int result;
 	int i;
@@ -2259,13 +2330,12 @@ int storage_set_tracker_client_ips(ConnectionInfo *conn,
             if ((result=fdfs_check_and_format_ips(&g_tracker_client_ip,
                         error_info, sizeof(error_info))) != 0)
             {
+                format_ip_address(conn->ip_addr, formatted_ip);
                 logCrit("file: "__FILE__", line: %d, "
                         "as a client of tracker server %s:%u, "
                         "my ip: %s not valid, error info: %s. "
-                        "program exit!", __LINE__,
-                        conn->ip_addr, conn->port,
-                        multi_ip.ips[i].address, error_info);
-
+                        "program exit!", __LINE__, formatted_ip,
+                        conn->port, multi_ip.ips[i].address, error_info);
                 return result;
             }
 
@@ -2277,11 +2347,12 @@ int storage_set_tracker_client_ips(ConnectionInfo *conn,
 
             fdfs_multi_ips_to_string(&g_tracker_client_ip,
                     ip_str, sizeof(ip_str));
+            format_ip_address(conn->ip_addr, formatted_ip);
             logError("file: "__FILE__", line: %d, "
                     "as a client of tracker server %s:%u, "
                     "my ip: %s not consistent with client ips: %s "
-                    "of other tracker client. program exit!", __LINE__,
-                    conn->ip_addr, conn->port,
+                    "of other tracker client. program exit!",
+                    __LINE__, formatted_ip, conn->port,
                     multi_ip.ips[i].address, ip_str);
 
             return result;

storage/storage_global.c

@@ -69,11 +69,12 @@ FDFSMultiIP g_last_storage_ip = {0, 0};	  //the last storage ip address
 
 LogContext g_access_log_context = {LOG_INFO, STDERR_FILENO, NULL};
 
-in_addr_t g_server_id_in_filename = 0;
+in_addr_64_t g_server_id_in_filename = 0;
 bool g_use_access_log = false;    //if log to access log
 bool g_rotate_access_log = false; //if rotate the access log every day
 bool g_compress_old_access_log = false; //if compress the old access log
 bool g_use_storage_id = false;    //identify storage by ID instead of IP address
+bool g_trust_storage_server_id = false;
 byte g_id_type_in_filename = FDFS_ID_TYPE_IP_ADDRESS; //id type of the storage server in the filename
 bool g_store_slave_file_use_link = false; //if store slave file use symbol link
 
@@ -82,7 +83,7 @@ byte g_file_signature_method = STORAGE_FILE_SIGNATURE_METHOD_HASH;
 char g_key_namespace[FDHT_MAX_NAMESPACE_LEN+1] = {0};
 int g_namespace_len = 0;
 int g_allow_ip_count = 0;
-in_addr_t *g_allow_ip_addrs = NULL;
+in_addr_64_t *g_allow_ip_addrs = NULL;
 StorageStatusPerTracker *g_my_report_status = NULL;  //returned by tracker server
 
 TimeInfo g_access_log_rotate_time = {0, 0}; //rotate access log time base

storage/storage_global.h

@@ -100,9 +100,10 @@ extern FDFSMultiIP g_last_storage_ip;	//the last storage ip address
 
 extern LogContext g_access_log_context;
 
-extern in_addr_t g_server_id_in_filename;
+extern in_addr_64_t g_server_id_in_filename;
 extern bool g_store_slave_file_use_link; //if store slave file use symbol link
 extern bool g_use_storage_id;  //identify storage by ID instead of IP address
+extern bool g_trust_storage_server_id;
 extern byte g_id_type_in_filename; //id type of the storage server in the filename
 extern bool g_use_access_log;  //if log to access log
 extern bool g_rotate_access_log;  //if rotate the access log every day
@@ -116,7 +117,7 @@ extern char g_key_namespace[FDHT_MAX_NAMESPACE_LEN+1];
 extern int g_namespace_len;
 
 extern int g_allow_ip_count;  /* -1 means match any ip address */
-extern in_addr_t *g_allow_ip_addrs;  /* sorted array, asc order */
+extern in_addr_64_t *g_allow_ip_addrs;  /* sorted array, asc order */
 
 extern StorageStatusPerTracker *g_my_report_status;  //returned by tracker server
 

storage/storage_ip_changed_dealer.c

@@ -32,6 +32,7 @@ static int storage_do_changelog_req(ConnectionInfo *pTrackerServer)
 {
 	char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
 			FDFS_STORAGE_ID_MAX_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	TrackerHeader *pHeader;
 	int result;
 
@@ -44,15 +45,14 @@ static int storage_do_changelog_req(ConnectionInfo *pTrackerServer)
 	strcpy(out_buff + sizeof(TrackerHeader), g_group_name);
 	strcpy(out_buff + sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN,
 		g_my_server_id_str);
-	if((result=tcpsenddata_nb(pTrackerServer->sock, out_buff, \
+	if((result=tcpsenddata_nb(pTrackerServer->sock, out_buff,
 		sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u, send data fail, " \
-			"errno: %d, error info: %s.", \
-			__LINE__, pTrackerServer->ip_addr, \
-			pTrackerServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u, send data fail, "
+			"errno: %d, error info: %s.", __LINE__, formatted_ip,
+			pTrackerServer->port, result, STRERROR(result));
 		return result;
 	}
 
@@ -64,6 +64,7 @@ static int storage_report_ip_changed(ConnectionInfo *pTrackerServer)
 	char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + \
 		2 * IP_ADDRESS_SIZE];
 	char in_buff[1];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char *pInBuff;
 	TrackerHeader *pHeader;
 	int result;
@@ -83,10 +84,10 @@ static int storage_report_ip_changed(ConnectionInfo *pTrackerServer)
 	if((result=tcpsenddata_nb(pTrackerServer->sock, out_buff, \
 		sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u, send data fail, " \
-			"errno: %d, error info: %s", \
-			__LINE__, pTrackerServer->ip_addr, \
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u, send data fail, "
+			"errno: %d, error info: %s", __LINE__, formatted_ip,
 			pTrackerServer->port, result, STRERROR(result));
 		return result;
 	}
@@ -108,12 +109,12 @@ static int storage_report_ip_changed(ConnectionInfo *pTrackerServer)
 	}
 	else
 	{
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
 		logError("file: "__FILE__", line: %d, "
 			"tracker server %s:%u, recv data fail or "
-			"response status != 0, "
-			"errno: %d, error info: %s",
-			__LINE__, pTrackerServer->ip_addr,
-			pTrackerServer->port, result, STRERROR(result));
+			"response status != 0, errno: %d, error info: %s",
+			__LINE__, formatted_ip, pTrackerServer->port,
+            result, STRERROR(result));
 		return result == EBUSY ? 0 : result;
 	}
 }
@@ -126,6 +127,7 @@ int storage_get_my_tracker_client_ip()
 	TrackerServerInfo trackerServer;
     ConnectionInfo *conn;
 	char tracker_client_ip[IP_ADDRESS_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	int success_count;
 	int result;
 	int i;
@@ -146,7 +148,8 @@ int storage_get_my_tracker_client_ip()
 		for (i=0; i < 3; i++)
 		{
             conn = tracker_connect_server_no_pool_ex(pTServer,
-                    g_client_bind_addr ? SF_G_INNER_BIND_ADDR : NULL,
+                    (g_client_bind_addr ? SF_G_INNER_BIND_ADDR4 : NULL),
+                    (g_client_bind_addr ? SF_G_INNER_BIND_ADDR6 : NULL),
                     &result, false);
             if (conn != NULL)
             {
@@ -158,12 +161,11 @@ int storage_get_my_tracker_client_ip()
 
 		if (conn == NULL)
 		{
+            format_ip_address(pTServer->connections[0].ip_addr, formatted_ip);
 			logError("file: "__FILE__", line: %d, "
 				"connect to tracker server %s:%u fail, "
-				"errno: %d, error info: %s",
-				__LINE__, pTServer->connections[0].ip_addr,
-                pTServer->connections[0].port,
-				result, STRERROR(result));
+				"errno: %d, error info: %s", __LINE__, formatted_ip,
+                pTServer->connections[0].port, result, STRERROR(result));
 
 			continue;
 		}
@@ -198,6 +200,7 @@ static int storage_report_storage_ip_addr()
 	TrackerServerInfo *pTServer;
 	TrackerServerInfo *pTServerEnd;
 	TrackerServerInfo trackerServer;
+    char formatted_ip[FORMATTED_IP_SIZE];
     ConnectionInfo *conn;
 	int success_count;
 	int result;
@@ -234,7 +237,8 @@ static int storage_report_storage_ip_addr()
 		for (i=0; i < 3; i++)
 		{
             conn = tracker_connect_server_no_pool_ex(pTServer,
-                    g_client_bind_addr ? SF_G_INNER_BIND_ADDR : NULL,
+                    (g_client_bind_addr ? SF_G_INNER_BIND_ADDR4 : NULL),
+                    (g_client_bind_addr ? SF_G_INNER_BIND_ADDR6 : NULL),
                     &result, false);
             if (conn != NULL)
             {
@@ -246,12 +250,11 @@ static int storage_report_storage_ip_addr()
 
         if (conn == NULL)
 		{
+            format_ip_address(pTServer->connections[0].ip_addr, formatted_ip);
 			logError("file: "__FILE__", line: %d, "
 				"connect to tracker server %s:%u fail, "
-				"errno: %d, error info: %s",
-				__LINE__, pTServer->connections[0].ip_addr,
-                pTServer->connections[0].port,
-				result, STRERROR(result));
+				"errno: %d, error info: %s", __LINE__, formatted_ip,
+                pTServer->connections[0].port, result, STRERROR(result));
 
 			continue;
 		}
@@ -284,6 +287,7 @@ int storage_changelog_req()
 	TrackerServerInfo *pTServer;
 	TrackerServerInfo *pTServerEnd;
 	TrackerServerInfo trackerServer;
+    char formatted_ip[FORMATTED_IP_SIZE];
     ConnectionInfo *conn;
 	int success_count;
 	int result;
@@ -304,7 +308,8 @@ int storage_changelog_req()
 		for (i=0; i < 3; i++)
 		{
             conn = tracker_connect_server_no_pool_ex(pTServer,
-                    g_client_bind_addr ? SF_G_INNER_BIND_ADDR : NULL,
+                    (g_client_bind_addr ? SF_G_INNER_BIND_ADDR4 : NULL),
+                    (g_client_bind_addr ? SF_G_INNER_BIND_ADDR6 : NULL),
                     &result, false);
             if (conn != NULL)
             {
@@ -316,12 +321,11 @@ int storage_changelog_req()
 
         if (conn == NULL)
 		{
+            format_ip_address(pTServer->connections[0].ip_addr, formatted_ip);
 			logError("file: "__FILE__", line: %d, "
 				"connect to tracker server %s:%u fail, "
-				"errno: %d, error info: %s",
-				__LINE__, pTServer->connections[0].ip_addr,
-                pTServer->connections[0].port,
-				result, STRERROR(result));
+				"errno: %d, error info: %s", __LINE__, formatted_ip,
+                pTServer->connections[0].port, result, STRERROR(result));
 
 			continue;
 		}

storage/storage_param_getter.c

@@ -74,9 +74,10 @@ int storage_get_params_from_tracker()
 	char reserved_space_str[32];
 	char *pIdType;
 
-	if ((result=fdfs_get_ini_context_from_tracker(&g_tracker_group,
-		&iniContext, (bool * volatile)&SF_G_CONTINUE_FLAG,
-		g_client_bind_addr, SF_G_INNER_BIND_ADDR)) != 0)
+	if ((result=fdfs_get_ini_context_from_tracker_ex(&g_tracker_group,
+                    &iniContext, (bool * volatile)&SF_G_CONTINUE_FLAG,
+                    g_client_bind_addr, SF_G_INNER_BIND_ADDR4,
+                    SF_G_INNER_BIND_ADDR6)) != 0)
 	{
 		return result;
 	}
@@ -178,6 +179,8 @@ int storage_get_params_from_tracker()
 	{
 		g_id_type_in_filename = FDFS_ID_TYPE_IP_ADDRESS;
 	}
+	g_trust_storage_server_id = iniGetBoolValue(NULL,
+			"trust_storage_server_id", &iniContext, false);
 
 	iniFreeContext(&iniContext);
 
@@ -193,6 +196,7 @@ int storage_get_params_from_tracker()
 	logInfo("file: "__FILE__", line: %d, "
 		"use_storage_id=%d, "
 		"id_type_in_filename=%s, "
+        "trust_storage_server_id=%d, "
 		"storage_ip_changed_auto_adjust=%d, "
 		"store_path=%d, "
 		"reserved_storage_space=%s, "
@@ -216,6 +220,7 @@ int storage_get_params_from_tracker()
 		"store_slave_file_use_link=%d",
 		__LINE__, g_use_storage_id,
 		g_id_type_in_filename == FDFS_ID_TYPE_SERVER_ID ? "id" : "ip",
+        g_trust_storage_server_id,
 		g_storage_ip_changed_auto_adjust,
 		g_store_path_mode, fdfs_storage_reserved_space_to_string(
 			&g_storage_reserved_space, reserved_space_str),

storage/storage_service.c

@@ -40,6 +40,7 @@
 #include "storage_global.h"
 #include "fastcommon/base64.h"
 #include "fastcommon/hash.h"
+#include "fastcommon/ioevent_loop.h"
 #include "fdht_client.h"
 #include "fdfs_global.h"
 #include "tracker_client.h"
@@ -49,7 +50,7 @@
 #include "trunk_mem.h"
 #include "trunk_sync.h"
 #include "trunk_client.h"
-#include "fastcommon/ioevent_loop.h"
+#include "file_id_hashtable.h"
 
 //storage access log actions
 #define ACCESS_LOG_ACTION_UPLOAD_FILE    "upload"
@@ -1559,12 +1560,12 @@ int storage_set_body_length(struct fast_task_info *pTask)
 }
 
 static int sock_accept_done_callback(struct fast_task_info *task,
-        const in_addr_t client_addr, const bool bInnerPort)
+        const in_addr_64_t client_addr, const bool bInnerPort)
 {
     if (g_allow_ip_count >= 0)
     {
         if (bsearch(&client_addr, g_allow_ip_addrs,
-                    g_allow_ip_count, sizeof(in_addr_t),
+                    g_allow_ip_count, sizeof(in_addr_64_t),
                     cmp_by_ip_addr_t) == NULL)
         {
             logError("file: "__FILE__", line: %d, "
@@ -1782,7 +1783,7 @@ void storage_get_store_path(const char *filename, const int filename_len, \
 	{ \
 		int r; \
 		r = (rand() & 0x007FFFFF) | 0x80000000; \
-		masked_file_size = (((int64_t)r) << 32 ) | file_size; \
+		masked_file_size = (((int64_t)r) << 32 ) | (file_size); \
 	} while (0)
 
 
@@ -1801,18 +1802,30 @@ static int storage_gen_filename(StorageClientInfo *pClientInfo,
 	int2buff(htonl(g_server_id_in_filename), buff);
 	int2buff(timestamp, buff+sizeof(int));
 	if ((file_size >> 32) != 0)
-	{
-		masked_file_size = file_size;
-	}
+    {
+        if (IS_TRUNK_FILE(file_size))
+        {
+            COMBINE_RAND_FILE_SIZE(file_size & 0xFFFFFFFF, masked_file_size);
+            masked_file_size |= FDFS_TRUNK_FILE_MARK_SIZE;
+        }
+        else if (IS_APPENDER_FILE(file_size))
+        {
+            COMBINE_RAND_FILE_SIZE(0, masked_file_size);
+            masked_file_size |= FDFS_APPENDER_FILE_SIZE;
+        }
+        else
+        {
+            masked_file_size = file_size;
+        }
+    }
 	else
 	{
 		COMBINE_RAND_FILE_SIZE(file_size, masked_file_size);
 	}
 	long2buff(masked_file_size, buff+sizeof(int)*2);
 	int2buff(crc32, buff+sizeof(int)*4);
-
-	base64_encode_ex(&g_fdfs_base64_context, buff, sizeof(int) * 5, encoded, \
-			filename_len, false);
+	base64_encode_ex(&g_fdfs_base64_context, buff, sizeof(int) * 5,
+            encoded, filename_len, false);
 
 	if (!pClientInfo->file_context.extra_info.upload.if_sub_path_alloced)
 	{
@@ -1903,9 +1916,12 @@ static int storage_get_filename(StorageClientInfo *pClientInfo,
 	int i;
 	int result;
 	int store_path_index;
+    string_t file_id;
+    char buff[128];
 
 	store_path_index = pClientInfo->file_context.extra_info.upload.
 				trunk_info.path.store_path_index;
+    file_id.str = buff;
 	for (i=0; i<10; i++)
 	{
 		if ((result=storage_gen_filename(pClientInfo, file_size,
@@ -1915,26 +1931,28 @@ static int storage_get_filename(StorageClientInfo *pClientInfo,
 			return result;
 		}
 
-		sprintf(full_filename, "%s/data/%s",
-			g_fdfs_store_paths.paths[store_path_index].path, filename);
-		if (!fileExists(full_filename))
-		{
-			break;
-		}
-
-		*full_filename = '\0';
+        file_id.len = snprintf(buff, sizeof(buff),
+                "%c"FDFS_STORAGE_DATA_DIR_FORMAT"/%s",
+                FDFS_STORAGE_STORE_PATH_PREFIX_CHAR,
+                store_path_index, filename);
+        if ((result=file_id_hashtable_add(&file_id)) == 0) //check duplicate
+        {
+            sprintf(full_filename, "%s/data/%s", g_fdfs_store_paths.
+                    paths[store_path_index].path, filename);
+            break;
+        }
 	}
 
-	if (*full_filename == '\0')
-	{
-		logError("file: "__FILE__", line: %d, "
-			"Can't generate uniq filename", __LINE__);
-		*filename = '\0';
-		*filename_len = 0;
-		return ENOENT;
-	}
+	if (result != 0)
+    {
+        logError("file: "__FILE__", line: %d, "
+                "Can't generate uniq filename", __LINE__);
+        *filename = '\0';
+        *filename_len = 0;
+        *full_filename = '\0';
+    }
 
-	return 0;
+	return result;
 }
 
 static int storage_client_create_link_wrapper(struct fast_task_info *pTask, \
@@ -2072,11 +2090,10 @@ static int storage_service_upload_file_done(struct fast_task_info *pTask)
 	*new_filename = '\0';
 	new_filename_len = 0;
 	if (pFileContext->extra_info.upload.file_type & _FILE_TYPE_TRUNK)
-	{
-		end_time = pFileContext->extra_info.upload.start_time;
-		COMBINE_RAND_FILE_SIZE(file_size, file_size_in_name);
-		file_size_in_name |= FDFS_TRUNK_FILE_MARK_SIZE;
-	}
+    {
+        end_time = pFileContext->extra_info.upload.start_time;
+        file_size_in_name = FDFS_TRUNK_FILE_MARK_SIZE | file_size;
+    }
 	else
 	{
 		struct stat stat_buf;
@@ -2093,10 +2110,9 @@ static int storage_service_upload_file_done(struct fast_task_info *pTask)
 		}
 
 		if (pFileContext->extra_info.upload.file_type & _FILE_TYPE_APPENDER)
-		{
-			COMBINE_RAND_FILE_SIZE(0, file_size_in_name);
-			file_size_in_name |= FDFS_APPENDER_FILE_SIZE;
-		}
+        {
+            file_size_in_name = FDFS_APPENDER_FILE_SIZE;
+        }
 		else
 		{
 			file_size_in_name = file_size;
@@ -5283,7 +5299,7 @@ static int storage_upload_slave_file(struct fast_task_info *pTask)
 			store_path_index, filename);
 	}
 
-	snprintf(pFileContext->filename, sizeof(pFileContext->filename), \
+	snprintf(pFileContext->filename, sizeof(pFileContext->filename),
 		"%s/data/%s", g_fdfs_store_paths.paths[store_path_index].path, filename);
 	if (fileExists(pFileContext->filename))
 	{

storage/storage_sync.c

@@ -96,6 +96,7 @@ static int storage_sync_copy_file(ConnectionInfo *pStorageServer, \
 	char *pBuff;
 	char full_filename[MAX_PATH_SIZE];
 	char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+256];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char in_buff[1];
 	struct stat stat_buf;
 	FDFSTrunkFullInfo trunkInfo;
@@ -145,26 +146,26 @@ static int storage_sync_copy_file(ConnectionInfo *pStorageServer, \
 		{
 			if (file_info.file_size == stat_buf.st_size)
 			{
-				logDebug("file: "__FILE__", line: %d, " \
-					"sync data file, logic file: %s " \
-					"on dest server %s:%u already exists, "\
-					"and same as mine, ignore it", \
-					__LINE__, pRecord->filename, \
-					pStorageServer->ip_addr, \
-					pStorageServer->port);
+                if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
+                    format_ip_address(pStorageServer->ip_addr, formatted_ip);
+                    logDebug("file: "__FILE__", line: %d, "
+                            "sync data file, logic file: %s "
+                            "on dest server %s:%u already exists, "
+                            "and same as mine, ignore it", __LINE__,
+                            pRecord->filename, formatted_ip,
+                            pStorageServer->port);
+                }
 				need_sync_file = false;
 			}
 			else
 			{
-				logWarning("file: "__FILE__", line: %d, " \
-					"sync data file, logic file: %s " \
-					"on dest server %s:%u already exists, "\
-					"but file size: %"PRId64 \
-					" not same as mine: %"PRId64 \
-					", need re-sync it", __LINE__, \
-					pRecord->filename, pStorageServer->ip_addr,\
-					pStorageServer->port, \
-					file_info.file_size, \
+                format_ip_address(pStorageServer->ip_addr, formatted_ip);
+				logWarning("file: "__FILE__", line: %d, "
+					"sync data file, logic file: %s "
+					"on dest server %s:%u already exists, "
+					"but file size: %"PRId64" not same as mine: %"PRId64
+					", need re-sync it", __LINE__, pRecord->filename,
+                    formatted_ip, pStorageServer->port, file_info.file_size,
                     (int64_t)stat_buf.st_size);
 
 				proto_cmd = STORAGE_PROTO_CMD_SYNC_UPDATE_FILE;
@@ -227,16 +228,14 @@ static int storage_sync_copy_file(ConnectionInfo *pStorageServer, \
 		memcpy(p, pRecord->filename, pRecord->filename_len);
 		p += pRecord->filename_len;
 
-		if((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
+		if((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
 			p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
 		{
-			logError("file: "__FILE__", line: %d, " \
-				"sync data to storage server %s:%u fail, " \
-				"errno: %d, error info: %s", \
-				__LINE__, pStorageServer->ip_addr, \
-				pStorageServer->port, \
-				result, STRERROR(result));
-
+            format_ip_address(pStorageServer->ip_addr, formatted_ip);
+			logError("file: "__FILE__", line: %d, "
+				"sync data to storage server %s:%u fail, errno: %d, "
+				"error info: %s", __LINE__, formatted_ip,
+				pStorageServer->port, result, STRERROR(result));
 			break;
 		}
 
@@ -245,13 +244,11 @@ static int storage_sync_copy_file(ConnectionInfo *pStorageServer, \
 			full_filename, file_offset, stat_buf.st_size, \
 			SF_G_NETWORK_TIMEOUT, &total_send_bytes)) != 0))
 		{
-			logError("file: "__FILE__", line: %d, " \
-				"sync data to storage server %s:%u fail, " \
-				"errno: %d, error info: %s", \
-				__LINE__, pStorageServer->ip_addr, \
-				pStorageServer->port, \
-				result, STRERROR(result));
-
+            format_ip_address(pStorageServer->ip_addr, formatted_ip);
+			logError("file: "__FILE__", line: %d, "
+				"sync data to storage server %s:%u fail, errno: %d, "
+				"error info: %s", __LINE__, formatted_ip,
+				pStorageServer->port, result, STRERROR(result));
 			break;
 		}
 
@@ -276,13 +273,13 @@ static int storage_sync_copy_file(ConnectionInfo *pStorageServer, \
 
 	if (result == EEXIST)
 	{
-		if (need_sync_file && pRecord->op_type == \
+		if (need_sync_file && pRecord->op_type ==
 			STORAGE_OP_TYPE_SOURCE_CREATE_FILE)
 		{
-			logWarning("file: "__FILE__", line: %d, " \
-				"storage server ip: %s:%u, data file: %s " \
-				"already exists, maybe some mistake?", \
-				__LINE__, pStorageServer->ip_addr, \
+            format_ip_address(pStorageServer->ip_addr, formatted_ip);
+			logWarning("file: "__FILE__", line: %d, "
+				"storage server ip: %s:%u, data file: %s already exists, "
+				"maybe some mistake?", __LINE__, formatted_ip,
 				pStorageServer->port, pRecord->filename);
 		}
 
@@ -320,6 +317,7 @@ static int storage_sync_modify_file(ConnectionInfo *pStorageServer, \
 	char *fields[SYNC_MODIFY_FIELD_COUNT];
 	char full_filename[MAX_PATH_SIZE];
 	char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+256];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char in_buff[1];
 	struct stat stat_buf;
 	int64_t in_bytes;
@@ -427,13 +425,11 @@ static int storage_sync_modify_file(ConnectionInfo *pStorageServer, \
 		if((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
 			p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
 		{
-			logError("file: "__FILE__", line: %d, " \
-				"sync data to storage server %s:%u fail, " \
-				"errno: %d, error info: %s", \
-				__LINE__, pStorageServer->ip_addr, \
-				pStorageServer->port, \
-				result, STRERROR(result));
-
+            format_ip_address(pStorageServer->ip_addr, formatted_ip);
+			logError("file: "__FILE__", line: %d, "
+				"sync data to storage server %s:%u fail, errno: %d, "
+				"error info: %s", __LINE__, formatted_ip,
+				pStorageServer->port, result, STRERROR(result));
 			break;
 		}
 
@@ -441,13 +437,11 @@ static int storage_sync_modify_file(ConnectionInfo *pStorageServer, \
 			full_filename, start_offset, modify_length, \
 			SF_G_NETWORK_TIMEOUT, &total_send_bytes)) != 0)
 		{
-			logError("file: "__FILE__", line: %d, " \
-				"sync data to storage server %s:%u fail, " \
-				"errno: %d, error info: %s", \
-				__LINE__, pStorageServer->ip_addr, \
-				pStorageServer->port, \
-				result, STRERROR(result));
-
+            format_ip_address(pStorageServer->ip_addr, formatted_ip);
+			logError("file: "__FILE__", line: %d, "
+				"sync data to storage server %s:%u fail, errno: %d, "
+				"error info: %s", __LINE__, formatted_ip,
+				pStorageServer->port, result, STRERROR(result));
 			break;
 		}
 
@@ -491,6 +485,7 @@ static int storage_sync_truncate_file(ConnectionInfo *pStorageServer, \
 	char *fields[SYNC_TRUNCATE_FIELD_COUNT];
 	char full_filename[MAX_PATH_SIZE];
 	char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+256];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char in_buff[1];
 	struct stat stat_buf;
 	int64_t in_bytes;
@@ -589,16 +584,14 @@ static int storage_sync_truncate_file(ConnectionInfo *pStorageServer, \
 		memcpy(p, pRecord->filename, pRecord->filename_len);
 		p += pRecord->filename_len;
 
-		if((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
+		if((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
 			p - out_buff, SF_G_NETWORK_TIMEOUT)) != 0)
 		{
-			logError("file: "__FILE__", line: %d, " \
-				"sync data to storage server %s:%u fail, " \
-				"errno: %d, error info: %s", \
-				__LINE__, pStorageServer->ip_addr, \
-				pStorageServer->port, \
-				result, STRERROR(result));
-
+            format_ip_address(pStorageServer->ip_addr, formatted_ip);
+			logError("file: "__FILE__", line: %d, "
+				"sync data to storage server %s:%u fail, errno: %d, "
+				"error info: %s", __LINE__, formatted_ip,
+				pStorageServer->port, result, STRERROR(result));
 			break;
 		}
 
@@ -627,6 +620,7 @@ static int storage_sync_delete_file(ConnectionInfo *pStorageServer, \
 {
 	TrackerHeader *pHeader;
 	char out_buff[sizeof(TrackerHeader)+FDFS_GROUP_NAME_MAX_LEN+256];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	struct stat stat_buf;
 	FDFSTrunkFullInfo trunkInfo;
 	FDFSTrunkHeader trunkHeader;
@@ -666,12 +660,11 @@ static int storage_sync_delete_file(ConnectionInfo *pStorageServer, \
 		sizeof(TrackerHeader) + 4 + FDFS_GROUP_NAME_MAX_LEN + \
 		pRecord->filename_len, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("FILE: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", \
-			__LINE__, pStorageServer->ip_addr, \
-			pStorageServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("FILE: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, errno: %d, "
+			"error info: %s", __LINE__, formatted_ip,
+			pStorageServer->port, result, STRERROR(result));
 		return result;
 	}
 
@@ -702,6 +695,7 @@ static int storage_report_my_server_id(ConnectionInfo *pStorageServer)
 	int result;
 	TrackerHeader *pHeader;
 	char out_buff[sizeof(TrackerHeader) + FDFS_STORAGE_ID_MAX_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char in_buff[1];
 	char *pBuff;
 	int64_t in_bytes;
@@ -716,12 +710,11 @@ static int storage_report_my_server_id(ConnectionInfo *pStorageServer)
 		sizeof(TrackerHeader) + FDFS_STORAGE_ID_MAX_SIZE, \
 		SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("FILE: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", \
-			__LINE__, pStorageServer->ip_addr, \
-			pStorageServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("FILE: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, errno: %d, "
+			"error info: %s", __LINE__, formatted_ip,
+			pStorageServer->port, result, STRERROR(result));
 		return result;
 	}
 
@@ -751,6 +744,7 @@ static int storage_sync_link_file(ConnectionInfo *pStorageServer, \
 	int result;
 	char out_buff[sizeof(TrackerHeader) + 2 * FDFS_PROTO_PKG_LEN_SIZE + \
 			4 + FDFS_GROUP_NAME_MAX_LEN + 256];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char in_buff[1];
 	FDFSTrunkFullInfo trunkInfo;
 	FDFSTrunkHeader trunkHeader;
@@ -937,16 +931,15 @@ static int storage_sync_link_file(ConnectionInfo *pStorageServer, \
 	long2buff(out_body_len, pHeader->pkg_len);
 	pHeader->cmd = STORAGE_PROTO_CMD_SYNC_CREATE_LINK;
 
-	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
-		sizeof(TrackerHeader) + out_body_len, \
+	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff,
+		sizeof(TrackerHeader) + out_body_len,
 		SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("FILE: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", \
-			__LINE__, pStorageServer->ip_addr, \
-			pStorageServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("FILE: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, errno: %d, "
+			"error info: %s", __LINE__, formatted_ip,
+			pStorageServer->port, result, STRERROR(result));
 		return result;
 	}
 
@@ -984,6 +977,7 @@ static int storage_sync_rename_file(ConnectionInfo *pStorageServer,
 	int result;
 	char out_buff[sizeof(TrackerHeader) + 2 * FDFS_PROTO_PKG_LEN_SIZE +
 			4 + FDFS_GROUP_NAME_MAX_LEN + 256];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char in_buff[1];
 	int out_body_len;
 	int64_t in_bytes;
@@ -1049,10 +1043,10 @@ static int storage_sync_rename_file(ConnectionInfo *pStorageServer,
 		sizeof(TrackerHeader) + out_body_len,
 		SF_G_NETWORK_TIMEOUT)) != 0)
 	{
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
 		logError("FILE: "__FILE__", line: %d, "
-			"send data to storage server %s:%u fail, "
-			"errno: %d, error info: %s",
-			__LINE__, pStorageServer->ip_addr,
+			"send data to storage server %s:%u fail, errno: %d, "
+			"error info: %s", __LINE__, formatted_ip,
 			pStorageServer->port, result, STRERROR(result));
 		return result;
 	}
@@ -1069,10 +1063,13 @@ static int storage_sync_rename_file(ConnectionInfo *pStorageServer,
         }
         else if (result == EEXIST)
         {
-			logDebug("file: "__FILE__", line: %d, "
-				"storage server ip: %s:%u, data file: %s "
-				"already exists", __LINE__, pStorageServer->ip_addr,
-				pStorageServer->port, pRecord->filename);
+            if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
+                format_ip_address(pStorageServer->ip_addr, formatted_ip);
+                logDebug("file: "__FILE__", line: %d, "
+                        "storage server ip: %s:%u, data file: %s "
+                        "already exists", __LINE__, formatted_ip,
+                        pStorageServer->port, pRecord->filename);
+            }
             return 0;
         }
         else
@@ -1997,6 +1994,7 @@ int storage_report_storage_status(const char *storage_id, \
 	TrackerServerInfo *pGlobalServer;
 	TrackerServerInfo *pTServer;
 	TrackerServerInfo *pTServerEnd;
+    char formatted_ip[FORMATTED_IP_SIZE];
     ConnectionInfo *conn;
 	int result;
 	int report_count;
@@ -2050,7 +2048,9 @@ int storage_report_storage_status(const char *storage_id, \
 		for (i=0; i < 3; i++)
 		{
             conn = tracker_connect_server_no_pool_ex(pTServer,
-                    g_client_bind_addr ? SF_G_INNER_BIND_ADDR : NULL, &result, false);
+                    (g_client_bind_addr ? SF_G_INNER_BIND_ADDR4 : NULL),
+                    (g_client_bind_addr ? SF_G_INNER_BIND_ADDR6 : NULL),
+                    &result, false);
             if (conn != NULL)
             {
 				break;
@@ -2061,12 +2061,12 @@ int storage_report_storage_status(const char *storage_id, \
 
         if (conn == NULL)
         {
+            format_ip_address(pTServer->connections[0].
+                    ip_addr, formatted_ip);
             logError("file: "__FILE__", line: %d, "
-                    "connect to tracker server %s:%u fail, "
-                    "errno: %d, error info: %s",
-                    __LINE__, pTServer->connections[0].ip_addr,
-                    pTServer->connections[0].port,
-                    result, STRERROR(result));
+                    "connect to tracker server %s:%u fail, errno: %d, "
+                    "error info: %s", __LINE__, formatted_ip, pTServer->
+                    connections[0].port, result, STRERROR(result));
             continue;
         }
 
@@ -2146,7 +2146,9 @@ static int storage_reader_sync_init_req(StorageBinLogReader *pReader)
 		while (SF_G_CONTINUE_FLAG)
 		{
             conn = tracker_connect_server_no_pool_ex(pTServer,
-                    g_client_bind_addr ? SF_G_INNER_BIND_ADDR : NULL, &result, true);
+                    (g_client_bind_addr ? SF_G_INNER_BIND_ADDR4 : NULL),
+                    (g_client_bind_addr ? SF_G_INNER_BIND_ADDR6 : NULL),
+                    &result, true);
             if (conn != NULL)
             {
 				break;
@@ -2857,6 +2859,7 @@ static void storage_sync_thread_exit(ConnectionInfo *pStorage)
 	int i;
     int thread_count;
 	pthread_t tid;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
 	if ((result=pthread_mutex_lock(&sync_thread_lock)) != 0)
 	{
@@ -2892,9 +2895,12 @@ static void storage_sync_thread_exit(ConnectionInfo *pStorage)
 			__LINE__, result, STRERROR(result));
 	}
 
-	logDebug("file: "__FILE__", line: %d, "
-		"sync thread to storage server %s:%u exit",
-		__LINE__, pStorage->ip_addr, pStorage->port);
+    if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
+        format_ip_address(pStorage->ip_addr, formatted_ip);
+        logDebug("file: "__FILE__", line: %d, "
+                "sync thread to storage server %s:%u exit",
+                __LINE__, formatted_ip, pStorage->port);
+    }
 }
 
 static void* storage_sync_thread_entrance(void* arg)
@@ -2904,6 +2910,7 @@ static void* storage_sync_thread_entrance(void* arg)
 	StorageBinLogRecord record;
 	ConnectionInfo storage_server;
 	char local_ip_addr[IP_ADDRESS_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	int read_result;
 	int sync_result;
 	int result;
@@ -2950,9 +2957,12 @@ static void* storage_sync_thread_entrance(void* arg)
 	start_time = 0;
 	end_time = 0;
 
-	logDebug("file: "__FILE__", line: %d, "
-		"sync thread to storage server %s:%u started",
-		__LINE__, storage_server.ip_addr, storage_server.port);
+    if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
+        format_ip_address(storage_server.ip_addr, formatted_ip);
+        logDebug("file: "__FILE__", line: %d, "
+                "sync thread to storage server %s:%u started",
+                __LINE__, formatted_ip, storage_server.port);
+    }
  
 	while (SF_G_CONTINUE_FLAG && \
 		pStorage->status != FDFS_STORAGE_STATUS_DELETED && \

storage/storage_sync_func.c

@@ -39,6 +39,8 @@ void storage_sync_connect_storage_server_ex(const FDFSStorageBrief *pStorage,
     int i;
     FDFSMultiIP ip_addrs;
     FDFSMultiIP *multi_ip;
+    const char *bind_addr;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
     multi_ip = NULL;
     if (g_use_storage_id)
@@ -83,9 +85,17 @@ void storage_sync_connect_storage_server_ex(const FDFSStorageBrief *pStorage,
         for (i=0; i<ip_addrs.count; i++)
         {
             strcpy(conn->ip_addr, ip_addrs.ips[i].address);
+            if (g_client_bind_addr)
+            {
+                bind_addr = is_ipv6_addr(conn->ip_addr) ?
+                    SF_G_INNER_BIND_ADDR6 : SF_G_INNER_BIND_ADDR4;
+            }
+            else
+            {
+                bind_addr = NULL;
+            }
             conn->sock = socketCreateExAuto(conn->ip_addr,
-                    O_NONBLOCK, g_client_bind_addr ?
-                    SF_G_INNER_BIND_ADDR : NULL, &result);
+                    O_NONBLOCK, bind_addr, &result);
             if (conn->sock < 0)
             {
                 logCrit("file: "__FILE__", line: %d, "
@@ -109,10 +119,12 @@ void storage_sync_connect_storage_server_ex(const FDFSStorageBrief *pStorage,
                             ", continuous fail count: %d",
                             nContinuousFail);
                 }
+
+                format_ip_address(conn->ip_addr, formatted_ip);
                 logInfo("file: "__FILE__", line: %d, "
                         "successfully connect to "
                         "storage server %s:%u%s", __LINE__,
-                        conn->ip_addr, SF_G_INNER_PORT, szFailPrompt);
+                        formatted_ip, SF_G_INNER_PORT, szFailPrompt);
                 nContinuousFail = 0;
                 break;
             }
@@ -120,10 +132,11 @@ void storage_sync_connect_storage_server_ex(const FDFSStorageBrief *pStorage,
             nContinuousFail++;
             if (previousCodes[i] != conn_results[i])
             {
+                format_ip_address(conn->ip_addr, formatted_ip);
                 logError("file: "__FILE__", line: %d, "
                         "connect to storage server %s:%u fail, "
                         "errno: %d, error info: %s",
-                        __LINE__, conn->ip_addr, SF_G_INNER_PORT,
+                        __LINE__, formatted_ip, SF_G_INNER_PORT,
                         conn_results[i], STRERROR(conn_results[i]));
                 previousCodes[i] = conn_results[i];
             }
@@ -146,10 +159,11 @@ void storage_sync_connect_storage_server_ex(const FDFSStorageBrief *pStorage,
         avg_fails = (nContinuousFail + ip_addrs.count - 1) / ip_addrs.count;
         for (i=0; i<ip_addrs.count; i++)
         {
+            format_ip_address(ip_addrs.ips[i].address, formatted_ip);
             logError("file: "__FILE__", line: %d, "
                     "connect to storage server %s:%u fail, "
                     "try count: %d, errno: %d, error info: %s",
-                    __LINE__, ip_addrs.ips[i].address, SF_G_INNER_PORT, avg_fails,
+                    __LINE__, formatted_ip, SF_G_INNER_PORT, avg_fails,
                     conn_results[i], STRERROR(conn_results[i]));
         }
     }

storage/storage_types.h

@@ -27,6 +27,10 @@
 #define FDFS_STORAGE_FILE_OP_DELETE   'D'
 #define FDFS_STORAGE_FILE_OP_DISCARD  'd'
 
+#define FDFS_TRUNK_FILE_CREATOR_TASK_ID     88
+#define FDFS_TRUNK_BINLOG_COMPRESS_TASK_ID  89
+#define FDFS_CLEAR_EXPIRED_FILE_ID_TASK_ID  90
+
 typedef int (*TaskDealFunc)(struct fast_task_info *pTask);
 
 /* this clean func will be called when connection disconnected */

storage/trunk_mgr/trunk_client.c

@@ -35,6 +35,7 @@ static int trunk_client_trunk_do_alloc_space(ConnectionInfo *pTrunkServer, \
 	char *p;
 	int result;
 	char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + 5];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	FDFSTrunkInfoBuff trunkBuff;
 	int64_t in_bytes;
 
@@ -50,15 +51,14 @@ static int trunk_client_trunk_do_alloc_space(ConnectionInfo *pTrunkServer, \
 	long2buff(FDFS_GROUP_NAME_MAX_LEN + 5, pHeader->pkg_len);
 	pHeader->cmd = STORAGE_PROTO_CMD_TRUNK_ALLOC_SPACE;
 
-	if ((result=tcpsenddata_nb(pTrunkServer->sock, out_buff, \
+	if ((result=tcpsenddata_nb(pTrunkServer->sock, out_buff,
 			sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pTrunkServer->ip_addr, pTrunkServer->port, \
-			result, STRERROR(result));
-
+        format_ip_address(pTrunkServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, errno: %d, "
+			"error info: %s", __LINE__, formatted_ip,
+            pTrunkServer->port, result, STRERROR(result));
 		return result;
 	}
 
@@ -74,11 +74,12 @@ static int trunk_client_trunk_do_alloc_space(ConnectionInfo *pTrunkServer, \
 
 	if (in_bytes != sizeof(FDFSTrunkInfoBuff))
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"storage server %s:%u, recv body length: %d invalid, " \
-			"expect body length: %d", __LINE__, \
-			pTrunkServer->ip_addr, pTrunkServer->port, \
-			(int)in_bytes, (int)sizeof(FDFSTrunkInfoBuff));
+        format_ip_address(pTrunkServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"storage server %s:%u, recv body length: %d invalid, "
+			"expect body length: %d", __LINE__, formatted_ip,
+            pTrunkServer->port, (int)in_bytes,
+            (int)sizeof(FDFSTrunkInfoBuff));
 		return EINVAL;
 	}
 
@@ -97,6 +98,7 @@ static int trunk_client_connect_trunk_server(TrackerServerInfo *trunk_server,
         ConnectionInfo **conn, const char *prompt)
 {
 	int result;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
 	if (g_trunk_server.count == 0)
 	{
@@ -108,10 +110,11 @@ static int trunk_client_connect_trunk_server(TrackerServerInfo *trunk_server,
 	memcpy(trunk_server, &g_trunk_server, sizeof(TrackerServerInfo));
 	if ((*conn=tracker_connect_server(trunk_server, &result)) == NULL)
 	{
+        format_ip_address(trunk_server->connections[0].
+                ip_addr, formatted_ip);
 		logError("file: "__FILE__", line: %d, "
-			"%s because connect to trunk "
-			"server %s:%u fail, errno: %d", __LINE__,
-			prompt, trunk_server->connections[0].ip_addr,
+			"%s because connect to trunk server %s:%u fail, "
+            "errno: %d", __LINE__, prompt, formatted_ip,
             trunk_server->connections[0].port, result);
 		return result;
 	}
@@ -167,6 +170,7 @@ static int trunk_client_trunk_confirm_or_free(ConnectionInfo *pTrunkServer,\
 	int result;
 	char out_buff[sizeof(TrackerHeader) \
 		+ STORAGE_TRUNK_ALLOC_CONFIRM_REQ_BODY_LEN];
+    char formatted_ip[FORMATTED_IP_SIZE];
 
 	pHeader = (TrackerHeader *)out_buff;
 	pTrunkBuff = (FDFSTrunkInfoBuff *)(out_buff + sizeof(TrackerHeader) \
@@ -185,15 +189,14 @@ static int trunk_client_trunk_confirm_or_free(ConnectionInfo *pTrunkServer,\
 	int2buff(pTrunkInfo->file.offset, pTrunkBuff->offset);
 	int2buff(pTrunkInfo->file.size, pTrunkBuff->size);
 
-	if ((result=tcpsenddata_nb(pTrunkServer->sock, out_buff, \
+	if ((result=tcpsenddata_nb(pTrunkServer->sock, out_buff,
 			sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pTrunkServer->ip_addr, pTrunkServer->port, \
-			result, STRERROR(result));
-
+        format_ip_address(pTrunkServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, errno: %d, "
+			"error info: %s", __LINE__, formatted_ip,
+            pTrunkServer->port, result, STRERROR(result));
 		return result;
 	}
 
@@ -207,11 +210,11 @@ static int trunk_client_trunk_confirm_or_free(ConnectionInfo *pTrunkServer,\
 
 	if (in_bytes != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"storage server %s:%u response data " \
-			"length: %"PRId64" is invalid, " \
-			"should == 0", __LINE__, pTrunkServer->ip_addr, \
-			pTrunkServer->port, in_bytes);
+        format_ip_address(pTrunkServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"storage server %s:%u response data length: "
+			"%"PRId64" is invalid, should == 0", __LINE__,
+            formatted_ip, pTrunkServer->port, in_bytes);
 		return EINVAL;
 	}
 

storage/trunk_mgr/trunk_shared.c

@@ -25,7 +25,6 @@
 #include "tracker_proto.h"
 
 FDFSStorePaths g_fdfs_store_paths = {0, NULL};
-struct base64_context g_fdfs_base64_context;
 BufferInfo g_zero_buffer = {NULL, 0, 0};
 
 int trunk_shared_init()

storage/trunk_mgr/trunk_shared.h

@@ -67,7 +67,6 @@ extern "C" {
 #endif
 
 extern FDFSStorePaths g_fdfs_store_paths;  //file store paths
-extern struct base64_context g_fdfs_base64_context;   //base64 context
 extern BufferInfo g_zero_buffer;   //zero buffer for reset
 
 typedef int (*stat_func)(const char *filename, struct stat *buf);

storage/trunk_mgr/trunk_sync.c

@@ -1953,6 +1953,7 @@ static void trunk_sync_thread_exit(TrunkSyncThreadInfo *thread_data,
         const int port)
 {
 	int result;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
 	if ((result=pthread_mutex_lock(&trunk_sync_thread_lock)) != 0)
 	{
@@ -1973,9 +1974,10 @@ static void trunk_sync_thread_exit(TrunkSyncThreadInfo *thread_data,
 			__LINE__, result, STRERROR(result));
 	}
 
+    format_ip_address(thread_data->pStorage->ip_addr, formatted_ip);
 	logInfo("file: "__FILE__", line: %d, "
 		"trunk sync thread to storage server %s:%u exit",
-		__LINE__, thread_data->pStorage->ip_addr, port);
+		__LINE__, formatted_ip, port);
 }
 
 static int trunk_sync_data(TrunkBinLogReader *pReader, \
@@ -1985,6 +1987,7 @@ static int trunk_sync_data(TrunkBinLogReader *pReader, \
 	char *p;
 	int result;
 	TrackerHeader header;
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char in_buff[1];
 	char *pBuff;
 	int64_t in_bytes;
@@ -2009,25 +2012,25 @@ static int trunk_sync_data(TrunkBinLogReader *pReader, \
 	memset(&header, 0, sizeof(header));
 	long2buff(length, header.pkg_len);
 	header.cmd = STORAGE_PROTO_CMD_TRUNK_SYNC_BINLOG;
-	if ((result=tcpsenddata_nb(pStorage->sock, &header, \
+	if ((result=tcpsenddata_nb(pStorage->sock, &header,
 		sizeof(TrackerHeader), SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("FILE: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", \
-			__LINE__, pStorage->ip_addr, pStorage->port, \
-			result, STRERROR(result));
+        format_ip_address(pStorage->ip_addr, formatted_ip);
+		logError("FILE: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, errno: %d, "
+			"error info: %s", __LINE__, formatted_ip,
+            pStorage->port, result, STRERROR(result));
 		return result;
 	}
 
-	if ((result=tcpsenddata_nb(pStorage->sock, pReader->binlog_buff.buffer,\
+	if ((result=tcpsenddata_nb(pStorage->sock, pReader->binlog_buff.buffer,
 		length, SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("FILE: "__FILE__", line: %d, " \
-			"send data to storage server %s:%u fail, " \
-			"errno: %d, error info: %s", \
-			__LINE__, pStorage->ip_addr, pStorage->port, \
-			result, STRERROR(result));
+        format_ip_address(pStorage->ip_addr, formatted_ip);
+		logError("FILE: "__FILE__", line: %d, "
+			"send data to storage server %s:%u fail, errno: %d, "
+			"error info: %s", __LINE__, formatted_ip, 
+            pStorage->port, result, STRERROR(result));
 		return result;
 	}
 
@@ -2057,6 +2060,7 @@ static void *trunk_sync_thread_entrance(void* arg)
 	TrunkBinLogReader reader;
 	ConnectionInfo storage_server;
 	char local_ip_addr[IP_ADDRESS_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	int read_result;
 	int sync_result;
 	int result;
@@ -2085,9 +2089,10 @@ static void *trunk_sync_thread_entrance(void* arg)
 	storage_server.port = SF_G_INNER_PORT;
 	storage_server.sock = -1;
 
-	logInfo("file: "__FILE__", line: %d, " \
+    format_ip_address(storage_server.ip_addr, formatted_ip);
+	logInfo("file: "__FILE__", line: %d, "
 		"trunk sync thread to storage server %s:%u started",
-		__LINE__, storage_server.ip_addr, storage_server.port);
+		__LINE__, formatted_ip, storage_server.port);
 
 	while (SF_G_CONTINUE_FLAG && g_if_trunker_self && \
 		pStorage->status != FDFS_STORAGE_STATUS_DELETED && \

test/test_types.h

@@ -13,7 +13,6 @@
 #define FILENAME_FILE_ID     "file_id"
 #define FILENAME_FAIL        "fail"
 
-#define IP_ADDRESS_SIZE		16
 #define SRAND_SEED		1225420780
 
 #define TIME_SUB_MS(tv1, tv2)  ((tv1.tv_sec - tv2.tv_sec) * 1000 + (tv1.tv_usec - tv2.tv_usec) / 1000)

tracker/fdfs_server_id_func.c

@@ -319,6 +319,7 @@ int fdfs_load_storage_ids(char *content, const char *pStorageIdsFilename)
 	char *group_name;
 	char *pHost;
 	char *pPort;
+    char *pSquare;
 	FDFSStorageIdInfo *pStorageIdInfo;
     char error_info[256];
 	int alloc_bytes;
@@ -405,18 +406,17 @@ int fdfs_load_storage_ids(char *content, const char *pStorageIdsFilename)
 			}
 		
 			pHost = group_name;
-			while (!(*pHost == ' ' || *pHost == '\t' \
-				|| *pHost == '\0'))
+			while (!(*pHost == ' ' || *pHost == '\t' || *pHost == '\0'))
 			{
 				pHost++;
 			}
 
 			if (*pHost == '\0')
 			{
-				logError("file: "__FILE__", line: %d, " \
-					"config file: %s, line no: %d, " \
-					"content: %s, invalid format, " \
-					"expect ip address!", __LINE__, \
+				logError("file: "__FILE__", line: %d, "
+					"config file: %s, line no: %d, "
+					"content: %s, invalid format, "
+					"expect ip address!", __LINE__,
 					pStorageIdsFilename, i + 1, line);
 				result = EINVAL;
 				break;
@@ -429,15 +429,43 @@ int fdfs_load_storage_ids(char *content, const char *pStorageIdsFilename)
 				pHost++;
 			}
 			
-            pPort = strchr(pHost, ':');
-            if (pPort != NULL)
+			if (*pHost == '[') //IPv6 address
             {
-                *pPort = '\0';
-                pStorageIdInfo->port = atoi(pPort + 1);
+                pHost++;  //skip [
+                pSquare = strchr(pHost, ']');
+                if (pSquare == NULL)
+                {
+                    result = EINVAL;
+                    logError("file: "__FILE__", line: %d, "
+                            "config file: %s, line no: %d, invalid IPv6 "
+                            "address: %s", __LINE__, pStorageIdsFilename,
+                            i + 1, pHost - 1);
+                    break;
+                }
+
+                *pSquare = '\0';
+                pPort = pSquare + 1;
+                if (*pPort == ':')
+                {
+                    pStorageIdInfo->port = atoi(pPort + 1);
+                }
+                else
+                {
+                    pStorageIdInfo->port = 0;
+                }
             }
             else
             {
-                pStorageIdInfo->port = 0;
+                pPort = strchr(pHost, ':');
+                if (pPort != NULL)
+                {
+                    *pPort = '\0';
+                    pStorageIdInfo->port = atoi(pPort + 1);
+                }
+                else
+                {
+                    pStorageIdInfo->port = 0;
+                }
             }
 
             if ((result=fdfs_parse_multi_ips(pHost, &pStorageIdInfo->ip_addrs,
@@ -460,9 +488,9 @@ int fdfs_load_storage_ids(char *content, const char *pStorageIdsFilename)
 
 			if (!fdfs_is_server_id_valid(id))
 			{
-				logError("file: "__FILE__", line: %d, " \
-					"invalid server id: \"%s\", " \
-					"which must be a none zero start " \
+				logError("file: "__FILE__", line: %d, "
+					"invalid server id: \"%s\", "
+					"which must be a none zero start "
 					"integer, such as 100001", __LINE__, id);
 				result = EINVAL;
 				break;
@@ -538,7 +566,8 @@ int fdfs_get_storage_ids_from_tracker_server(TrackerServerInfo *pTrackerServer)
 #define MAX_REQUEST_LOOP   32
 	TrackerHeader *pHeader;
 	ConnectionInfo *conn;
-	char out_buff[sizeof(TrackerHeader) + sizeof(int)];
+	char out_buff[sizeof(TrackerHeader) + sizeof(FDFSFetchStorageIdsBody)];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char *p;
 	char *response;
 	struct data_info {
@@ -564,7 +593,7 @@ int fdfs_get_storage_ids_from_tracker_server(TrackerServerInfo *pTrackerServer)
 	pHeader = (TrackerHeader *)out_buff;
 	p = out_buff + sizeof(TrackerHeader);
 	pHeader->cmd = TRACKER_PROTO_CMD_STORAGE_FETCH_STORAGE_IDS;
-	long2buff(sizeof(int), pHeader->pkg_len);
+	long2buff(sizeof(FDFSFetchStorageIdsBody), pHeader->pkg_len);
 
 	start_index = 0;
 	list_count = 0;
@@ -575,10 +604,11 @@ int fdfs_get_storage_ids_from_tracker_server(TrackerServerInfo *pTrackerServer)
 		if ((result=tcpsenddata_nb(conn->sock, out_buff,
 			sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
 		{
+            format_ip_address(conn->ip_addr, formatted_ip);
 			logError("file: "__FILE__", line: %d, "
 				"send data to tracker server %s:%u fail, "
 				"errno: %d, error info: %s", __LINE__,
-				conn->ip_addr, conn->port,
+				formatted_ip, conn->port,
 				result, STRERROR(result));
 		}
 		else
@@ -600,9 +630,10 @@ int fdfs_get_storage_ids_from_tracker_server(TrackerServerInfo *pTrackerServer)
 
 		if (in_bytes < 2 * sizeof(int))
 		{
+            format_ip_address(conn->ip_addr, formatted_ip);
 			logError("file: "__FILE__", line: %d, "
 				"tracker server %s:%u, recv data length: %d "
-				"is invalid", __LINE__, conn->ip_addr,
+				"is invalid", __LINE__, formatted_ip,
                 conn->port, (int)in_bytes);
 			result = EINVAL;
 			break;
@@ -612,10 +643,11 @@ int fdfs_get_storage_ids_from_tracker_server(TrackerServerInfo *pTrackerServer)
 		current_count = buff2int(response + sizeof(int));
 		if (total_count <= start_index)
 		{
+            format_ip_address(conn->ip_addr, formatted_ip);
 			logError("file: "__FILE__", line: %d, "
 				"tracker server %s:%u, total storage "
 				"count: %d is invalid, which <= start "
-				"index: %d", __LINE__, conn->ip_addr,
+				"index: %d", __LINE__, formatted_ip,
 				conn->port, total_count, start_index);
 			result = EINVAL;
 			break;
@@ -623,10 +655,11 @@ int fdfs_get_storage_ids_from_tracker_server(TrackerServerInfo *pTrackerServer)
 
 		if (current_count <= 0)
 		{
+            format_ip_address(conn->ip_addr, formatted_ip);
 			logError("file: "__FILE__", line: %d, "
 				"tracker server %s:%u, current storage "
 				"count: %d is invalid, which <= 0", __LINE__,
-                conn->ip_addr, conn->port, current_count);
+                formatted_ip, conn->port, current_count);
 			result = EINVAL;
 			break;
 		}
@@ -649,10 +682,11 @@ int fdfs_get_storage_ids_from_tracker_server(TrackerServerInfo *pTrackerServer)
 
 		if (list_count == MAX_REQUEST_LOOP)
 		{
+            format_ip_address(conn->ip_addr, formatted_ip);
 			logError("file: "__FILE__", line: %d, "
-				"response data from tracker "
-				"server %s:%u is too large",
-				__LINE__, conn->ip_addr, conn->port);
+				"response data from tracker server "
+				"%s:%u is too large", __LINE__,
+                formatted_ip, conn->port);
 			result = ENOSPC;
 			break;
 		}

tracker/fdfs_shared_func.c

@@ -10,10 +10,12 @@
 #include <string.h>
 #include <limits.h>
 #include <netdb.h>
+#include <ctype.h>
 #include "fastcommon/logger.h"
 #include "fastcommon/sockopt.h"
 #include "fastcommon/shared_func.h"
 #include "fastcommon/local_ip_func.h"
+#include "fastcommon/md5.h"
 #include "tracker_proto.h"
 #include "fdfs_global.h"
 #include "fdfs_shared_func.h"
@@ -201,19 +203,19 @@ int fdfs_parse_storage_reserved_space(IniContext *pIniContext,
 	char *pReservedSpaceStr;
 	int64_t storage_reserved;
 
-	pReservedSpaceStr = iniGetStrValue(NULL, \
+	pReservedSpaceStr = iniGetStrValue(NULL,
 			"reserved_storage_space", pIniContext);
 	if (pReservedSpaceStr == NULL)
 	{
-		pStorageReservedSpace->flag = \
+		pStorageReservedSpace->flag =
 				TRACKER_STORAGE_RESERVED_SPACE_FLAG_MB;
 		pStorageReservedSpace->rs.mb = FDFS_DEF_STORAGE_RESERVED_MB;
 		return 0;
 	}
 	if (*pReservedSpaceStr == '\0')
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"item \"reserved_storage_space\" is empty!", \
+		logError("file: "__FILE__", line: %d, "
+			"item \"reserved_storage_space\" is empty!",
 			__LINE__);
 		return EINVAL;
 	}
@@ -225,24 +227,22 @@ int fdfs_parse_storage_reserved_space(IniContext *pIniContext,
 		pStorageReservedSpace->flag = TRACKER_STORAGE_RESERVED_SPACE_FLAG_RATIO;
 		endptr = NULL;
 		*(pReservedSpaceStr + len - 1) = '\0';
-		pStorageReservedSpace->rs.ratio = \
+		pStorageReservedSpace->rs.ratio =
 					strtod(pReservedSpaceStr, &endptr);
 		if (endptr != NULL && *endptr != '\0')
 		{
-			logError("file: "__FILE__", line: %d, " \
-				"item \"reserved_storage_space\": %s%%"\
-				" is invalid!", __LINE__, \
-				pReservedSpaceStr);
+			logError("file: "__FILE__", line: %d, "
+				"item \"reserved_storage_space\": %s%%"
+				" is invalid!", __LINE__, pReservedSpaceStr);
 			return EINVAL;
 		}
 
-		if (pStorageReservedSpace->rs.ratio <= 0.00 || \
+		if (pStorageReservedSpace->rs.ratio <= 0.00 ||
 			pStorageReservedSpace->rs.ratio >= 100.00)
 		{
-			logError("file: "__FILE__", line: %d, " \
-				"item \"reserved_storage_space\": %s%%"\
-				" is invalid!", __LINE__, \
-				pReservedSpaceStr);
+			logError("file: "__FILE__", line: %d, "
+				"item \"reserved_storage_space\": %s%%"
+				" is invalid!", __LINE__, pReservedSpaceStr);
 			return EINVAL;
 		}
 
@@ -310,7 +310,7 @@ int64_t fdfs_get_storage_reserved_space_mb(const int64_t total_mb,
 bool fdfs_check_reserved_space(FDFSGroupInfo *pGroup, \
 	FDFSStorageReservedSpace *pStorageReservedSpace)
 {
-	if (pStorageReservedSpace->flag == \
+	if (pStorageReservedSpace->flag ==
 			TRACKER_STORAGE_RESERVED_SPACE_FLAG_MB)
 	{
 		return pGroup->free_mb > pStorageReservedSpace->rs.mb;
@@ -328,7 +328,7 @@ bool fdfs_check_reserved_space(FDFSGroupInfo *pGroup, \
 			pStorageReservedSpace->rs.ratio);
 		*/
 
-		return ((double)pGroup->free_mb / (double)pGroup->total_mb) > \
+		return ((double)pGroup->free_mb / (double)pGroup->total_mb) >
 			pStorageReservedSpace->rs.ratio;
 	}
 }
@@ -336,12 +336,12 @@ bool fdfs_check_reserved_space(FDFSGroupInfo *pGroup, \
 bool fdfs_check_reserved_space_trunk(FDFSGroupInfo *pGroup, \
 	FDFSStorageReservedSpace *pStorageReservedSpace)
 {
-	if (pStorageReservedSpace->flag == \
+	if (pStorageReservedSpace->flag ==
 			TRACKER_STORAGE_RESERVED_SPACE_FLAG_MB)
-	{
-		return (pGroup->free_mb + pGroup->trunk_free_mb > 
-			pStorageReservedSpace->rs.mb);
-	}
+    {
+        return (pGroup->free_mb + pGroup->trunk_free_mb >
+                pStorageReservedSpace->rs.mb);
+    }
 	else
 	{
 		if (pGroup->total_mb == 0)
@@ -351,20 +351,20 @@ bool fdfs_check_reserved_space_trunk(FDFSGroupInfo *pGroup, \
 
 		/*
 		logInfo("storage trunk=%.4f, rs.ratio=%.4f", 
-		((double)(pGroup->free_mb + pGroup->trunk_free_mb) / \
+		((double)(pGroup->free_mb + pGroup->trunk_free_mb) /
 		(double)pGroup->total_mb), pStorageReservedSpace->rs.ratio);
 		*/
 
-		return ((double)(pGroup->free_mb + pGroup->trunk_free_mb) / \
+		return ((double)(pGroup->free_mb + pGroup->trunk_free_mb) /
 		(double)pGroup->total_mb) > pStorageReservedSpace->rs.ratio;
 	}
 }
 
-bool fdfs_check_reserved_space_path(const int64_t total_mb, \
-	const int64_t free_mb, const int64_t avg_mb, \
+bool fdfs_check_reserved_space_path(const int64_t total_mb,
+	const int64_t free_mb, const int64_t avg_mb,
 	FDFSStorageReservedSpace *pStorageReservedSpace)
 {
-	if (pStorageReservedSpace->flag == \
+	if (pStorageReservedSpace->flag ==
 			TRACKER_STORAGE_RESERVED_SPACE_FLAG_MB)
 	{
 		return free_mb > avg_mb;
@@ -377,14 +377,14 @@ bool fdfs_check_reserved_space_path(const int64_t total_mb, \
 		}
 
 		/*
-		logInfo("storage path, free_mb=%"PRId64 \
-			", total_mb=%"PRId64", " \
-			"real ratio=%.4f, rs.ratio=%.4f", \
-			free_mb, total_mb, ((double)free_mb / total_mb), \
+		logInfo("storage path, free_mb=%"PRId64
+			", total_mb=%"PRId64", "
+			"real ratio=%.4f, rs.ratio=%.4f",
+			free_mb, total_mb, ((double)free_mb / total_mb),
 			pStorageReservedSpace->rs.ratio);
 		*/
 
-		return ((double)free_mb / (double)total_mb) > \
+		return ((double)free_mb / (double)total_mb) >
 			pStorageReservedSpace->rs.ratio;
 	}
 }
@@ -437,6 +437,7 @@ void fdfs_set_log_rotate_size(LogContext *pContext, const int64_t log_rotate_siz
 int fdfs_parse_server_info_ex(char *server_str, const int default_port,
         TrackerServerInfo *pServer, const bool resolve)
 {
+	char *pSquare;
 	char *pColon;
     char *hosts[FDFS_MULTI_IP_MAX_COUNT];
     ConnectionInfo *conn;
@@ -444,7 +445,30 @@ int fdfs_parse_server_info_ex(char *server_str, const int default_port,
     int i;
 
     memset(pServer, 0, sizeof(TrackerServerInfo));
-    if ((pColon=strrchr(server_str, ':')) == NULL)
+    if (*server_str == '[')
+    {
+        server_str++;
+        if ((pSquare=strchr(server_str, ']')) == NULL)
+        {
+            logError("file: "__FILE__", line: %d, "
+                    "host \"%s\" is invalid",
+                    __LINE__, server_str - 1);
+            return EINVAL;
+        }
+
+        *pSquare = '\0';
+        pColon = pSquare + 1;  //skip ]
+        if (*pColon != ':')
+        {
+            pColon = NULL;
+        }
+    }
+    else
+    {
+        pColon = strrchr(server_str, ':');
+    }
+
+    if (pColon == NULL)
     {
         logInfo("file: "__FILE__", line: %d, "
                 "no port part in %s, set port to %d",
@@ -464,8 +488,8 @@ int fdfs_parse_server_info_ex(char *server_str, const int default_port,
     {
         if (resolve)
         {
-            if (getIpaddrByName(hosts[i], conn->ip_addr,
-                        sizeof(conn->ip_addr)) == INADDR_NONE)
+            if (getIpaddrByNameEx(hosts[i], conn->ip_addr,
+                        sizeof(conn->ip_addr), &conn->af) == INADDR_NONE)
             {
                 logError("file: "__FILE__", line: %d, "
                         "host \"%s\" is invalid, error info: %s",
@@ -476,7 +500,9 @@ int fdfs_parse_server_info_ex(char *server_str, const int default_port,
         else
         {
             snprintf(conn->ip_addr, sizeof(conn->ip_addr), "%s", hosts[i]);
+            conn->af = is_ipv6_addr(conn->ip_addr) ? AF_INET6 : AF_INET;
         }
+
         conn->port = port;
         conn->sock = -1;
         conn++;
@@ -491,25 +517,60 @@ int fdfs_server_info_to_string_ex(const TrackerServerInfo *pServer,
 	const ConnectionInfo *conn;
 	const ConnectionInfo *end;
     int len;
+    bool is_ipv6;
 
     if (pServer->count <= 0)
     {
         *buff = '\0';
         return 0;
     }
+
     if (pServer->count == 1)
     {
-        return snprintf(buff, buffSize, "%s:%u",
-                pServer->connections[0].ip_addr, port);
+        if (is_ipv6_addr(pServer->connections[0].ip_addr))
+        {
+            return snprintf(buff, buffSize, "[%s]:%u",
+                    pServer->connections[0].ip_addr, port);
+        }
+        else
+        {
+            return snprintf(buff, buffSize, "%s:%u",
+                    pServer->connections[0].ip_addr, port);
+        }
     }
 
-    len = snprintf(buff, buffSize, "%s", pServer->connections[0].ip_addr);
+    is_ipv6 = false;
 	end = pServer->connections + pServer->count;
+	for (conn=pServer->connections; conn<end; conn++)
+    {
+        if (is_ipv6_addr(conn->ip_addr))
+        {
+            is_ipv6 = true;
+            break;
+        }
+    }
+
+    if (is_ipv6)
+    {
+        *buff = '[';
+        len = 1;
+    }
+    else
+    {
+        len = 0;
+    }
+
+    len += snprintf(buff + len, buffSize - len, "%s",
+            pServer->connections[0].ip_addr);
 	for (conn=pServer->connections + 1; conn<end; conn++)
     {
         len += snprintf(buff + len, buffSize - len, ",%s", conn->ip_addr);
     }
-    len += snprintf(buff + len, buffSize - len, ":%d", port);
+    if (is_ipv6 && len < buffSize - 2)
+    {
+        *(buff + len++) = ']';
+    }
+    len += snprintf(buff + len, buffSize - len, ":%u", port);
     return len;
 }
 
@@ -781,3 +842,12 @@ void fdfs_set_server_info_ex(TrackerServerInfo *pServer,
     }
 }
 
+char *fdfs_ip_to_shortcode(const char *ipAddr, char *shortCode)
+{
+    int64_t crc64;
+    int len;
+
+    crc64 = CRC32_ex(ipAddr, strlen(ipAddr), CRC32_XINIT);
+    return base64_encode(&g_fdfs_base64_context, (const char *)&crc64,
+            sizeof(crc64), shortCode, &len);
+}

tracker/fdfs_shared_func.h

@@ -167,6 +167,8 @@ void fdfs_set_server_info(TrackerServerInfo *pServer,
 void fdfs_set_server_info_ex(TrackerServerInfo *pServer,
         const FDFSMultiIP *ip_addrs, const int port);
 
+char *fdfs_ip_to_shortcode(const char *ipAddr, char *shortCode);
+
 #ifdef __cplusplus
 }
 #endif

tracker/fdfs_trackerd.c

@@ -220,7 +220,7 @@ int main(int argc, char *argv[])
 		return result;
 	}
 
-	base64_init_ex(&g_base64_context, 0, '-', '_', '.');
+	base64_init_ex(&g_fdfs_base64_context, 0, '-', '_', '.');
 	if ((result=set_rand_seed()) != 0)
 	{
 		logCrit("file: "__FILE__", line: %d, " \
@@ -423,14 +423,30 @@ static void sigAlarmHandler(int sig)
 	logDebug("file: "__FILE__", line: %d, " \
 		"signal server to quit...", __LINE__);
 
-	if (*g_sf_context.inner_bind_addr != '\0')
-	{
-		strcpy(server.ip_addr, g_sf_context.inner_bind_addr);
-	}
-	else
-	{
-		strcpy(server.ip_addr, "127.0.0.1");
-	}
+    if (SF_G_IPV4_ENABLED)
+    {
+        server.af = AF_INET;
+        if (*SF_G_INNER_BIND_ADDR4 != '\0')
+        {
+            strcpy(server.ip_addr, SF_G_INNER_BIND_ADDR4);
+        }
+        else
+        {
+            strcpy(server.ip_addr, LOCAL_LOOPBACK_IPv4);
+        }
+    }
+    else
+    {
+        server.af = AF_INET6;
+        if (*SF_G_INNER_BIND_ADDR6 != '\0')
+        {
+            strcpy(server.ip_addr, SF_G_INNER_BIND_ADDR6);
+        }
+        else
+        {
+            strcpy(server.ip_addr, LOCAL_LOOPBACK_IPv6);
+        }
+    }
 	server.port = SF_G_INNER_PORT;
 	server.sock = -1;
 

tracker/tracker_dump.c

@@ -298,7 +298,7 @@ static int fdfs_dump_global_vars(char *buff, const int buffSize)
 		"SF_G_CONTINUE_FLAG=%d\n"
 		"g_schedule_flag=%d\n"
 		"SF_G_INNER_PORT=%d\n"
-		"g_max_connections=%d\n"
+		"SF_G_MAX_CONNECTIONS=%d\n"
 		"g_tracker_thread_count=%d\n"
 		"g_sync_log_buff_interval=%ds\n"
 		"g_check_active_interval=%ds\n"
@@ -352,7 +352,7 @@ static int fdfs_dump_global_vars(char *buff, const int buffSize)
         , g_fdfs_version.patch, SF_G_CONTINUE_FLAG
 		, g_schedule_flag
 		, SF_G_INNER_PORT
-		, g_sf_global_vars.max_connections
+		, SF_G_MAX_CONNECTIONS
 		, g_sf_context.thread_count
 		, g_sf_global_vars.error_log.sync_log_buff_interval
 		, g_check_active_interval
@@ -444,9 +444,8 @@ static int fdfs_dump_tracker_servers(char *buff, const int buffSize)
         fdfs_server_info_to_string(pTrackerServer, ip_str, sizeof(ip_str));
 
 		total_len += snprintf(buff + total_len, buffSize - total_len,
-			"\t%d. tracker server=%s:%u\n", \
-			(int)(pTrackerServer - g_tracker_servers.servers) + 1, \
-			ip_str, pTrackerServer->connections[0].port);
+			"\t%d. tracker server=%s\n", (int)(pTrackerServer -
+                g_tracker_servers.servers) + 1, ip_str);
 	}
 
 	return total_len;

tracker/tracker_func.c

@@ -89,7 +89,7 @@ static int tracker_load_store_lookup(const char *filename, \
 	if (fdfs_validate_group_name(g_groups.store_group) != 0) \
 	{
 		logError("file: "__FILE__", line: %d, " \
-			"conf file \"%s\", " \
+			"config file \"%s\", " \
 			"the group name \"%s\" is invalid!", \
 			__LINE__, filename, g_groups.store_group);
 		return EINVAL;
@@ -98,30 +98,46 @@ static int tracker_load_store_lookup(const char *filename, \
 	return 0;
 }
 
-static int tracker_load_storage_id_info(const char *config_filename, \
-		IniContext *pItemContext)
+static int tracker_load_storage_id_info(const char *config_filename,
+		IniContext *iniContext)
 {
 	char *pIdType;
 
-	g_use_storage_id = iniGetBoolValue(NULL, "use_storage_id", \
-				pItemContext, false);
+	g_use_storage_id = iniGetBoolValue(NULL, "use_storage_id",
+				iniContext, false);
 	if (!g_use_storage_id)
 	{
+        if (SF_G_IPV6_ENABLED)
+        {
+            logError("file: "__FILE__", line: %d, "
+                    "config file: %s, use_storage_id MUST set to true "
+                    "when IPv6 enabled!", __LINE__, config_filename);
+            return EINVAL;
+        }
+
 		return 0;
 	}
 
-	pIdType = iniGetStrValue(NULL, "id_type_in_filename", \
-			pItemContext);
+	pIdType = iniGetStrValue(NULL, "id_type_in_filename", iniContext);
 	if (pIdType != NULL && strcasecmp(pIdType, "id") == 0)
 	{
 		g_id_type_in_filename = FDFS_ID_TYPE_SERVER_ID;
 	}
 	else
-	{
-		g_id_type_in_filename = FDFS_ID_TYPE_IP_ADDRESS;
-	}
+    {
+        if (SF_G_IPV6_ENABLED)
+        {
+            logError("file: "__FILE__", line: %d, "
+                    "config file: %s, id_type_in_filename MUST set to id "
+                    "when IPv6 enabled!", __LINE__, config_filename);
+            return EINVAL;
+        }
+        g_id_type_in_filename = FDFS_ID_TYPE_IP_ADDRESS;
+    }
 
-	return fdfs_load_storage_ids_from_file(config_filename, pItemContext);
+    g_trust_storage_server_id = iniGetBoolValue(NULL,
+            "trust_storage_server_id", iniContext, true);
+	return fdfs_load_storage_ids_from_file(config_filename, iniContext);
 }
 
 int tracker_load_from_conf_file(const char *filename)
@@ -175,7 +191,7 @@ int tracker_load_from_conf_file(const char *filename)
         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");
+                "buff_size", 0);
         if ((result=sf_load_config_ex("trackerd", &config, fixed_buffer_size,
                         task_buffer_extra_size, need_set_run_by)) != 0)
         {
@@ -520,6 +536,7 @@ int tracker_load_from_conf_file(const char *filename)
 			"trunk_binlog_max_backups=%d, "
 			"use_storage_id=%d, "
 			"id_type_in_filename=%s, "
+			"trust_storage_server_id=%d, "
 			"storage_id/ip_count=%d / %d, "
 			"store_slave_file_use_link=%d, "
 			"use_connection_pool=%d, "
@@ -555,6 +572,7 @@ int tracker_load_from_conf_file(const char *filename)
             g_trunk_binlog_max_backups,
 			g_use_storage_id, g_id_type_in_filename ==
 			FDFS_ID_TYPE_SERVER_ID ? "id" : "ip",
+            g_trust_storage_server_id,
             g_storage_ids_by_id.count, g_storage_ids_by_ip.count,
 			g_store_slave_file_use_link,
 			g_use_connection_pool, g_connection_pool_max_idle_time);

tracker/tracker_global.c

@@ -17,12 +17,11 @@ FDFSStorageReservedSpace g_storage_reserved_space = { \
 		TRACKER_STORAGE_RESERVED_SPACE_FLAG_MB};
 
 int g_allow_ip_count = 0;
-in_addr_t *g_allow_ip_addrs = NULL;
-
-struct base64_context g_base64_context;
+in_addr_64_t *g_allow_ip_addrs = NULL;
 
 bool g_storage_ip_changed_auto_adjust = true;
 bool g_use_storage_id = false;  //if use storage ID instead of IP address
+bool g_trust_storage_server_id = true;
 byte g_id_type_in_filename = FDFS_ID_TYPE_IP_ADDRESS; //id type of the storage server in the filename
 
 int g_storage_sync_file_max_delay = DEFAULT_STORAGE_SYNC_FILE_MAX_DELAY;

tracker/tracker_global.h

@@ -43,11 +43,11 @@ extern FDFSStorageReservedSpace g_storage_reserved_space;
 extern int g_check_active_interval; //check storage server alive every interval seconds
 
 extern int g_allow_ip_count;  /* -1 means match any ip address */
-extern in_addr_t *g_allow_ip_addrs;  /* sorted array, asc order */
-extern struct base64_context g_base64_context;
+extern in_addr_64_t *g_allow_ip_addrs;  /* sorted array, asc order */
 
 extern bool g_storage_ip_changed_auto_adjust;
 extern bool g_use_storage_id;  //identify storage by ID instead of IP address
+extern bool g_trust_storage_server_id;
 extern byte g_id_type_in_filename; //id type of the storage server in the filename
 
 extern int g_storage_sync_file_max_delay;

tracker/tracker_mem.c

@@ -1787,6 +1787,7 @@ int tracker_save_storages()
 	char trueFilename[MAX_PATH_SIZE];
 	char buff[4096];
 	char id_buff[128];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	int fd;
 	int len;
 	FDFSGroupInfo **ppGroup;
@@ -1838,6 +1839,7 @@ int tracker_save_storages()
 			}
 
 			count++;
+            format_ip_address(FDFS_CURRENT_IP_ADDR(pStorage), formatted_ip);
 			len = sprintf(buff, \
 				"# storage %s:%u\n" \
 				"[%s"STORAGE_SECTION_NO_FORMAT"]\n" \
@@ -1894,8 +1896,7 @@ int tracker_save_storages()
 				"\t%s=%d\n" \
 				"\t%s=%d\n" \
 				"\t%s=%"PRId64"\n\n", \
-                FDFS_CURRENT_IP_ADDR(pStorage), \
-				pStorage->storage_port, \
+                formatted_ip, pStorage->storage_port, \
 				STORAGE_SECTION_NAME_PREFIX, count, id_buff, \
 				STORAGE_ITEM_GROUP_NAME, \
 				(*ppGroup)->group_name, \
@@ -3180,9 +3181,17 @@ static FDFSStorageDetail *tracker_mem_get_active_http_server_by_ip( \
 
 	memset(&target_storage, 0, sizeof(target_storage));
 	if (!g_use_storage_id)
-	{
-		strcpy(target_storage.id, ip_addr);
-	}
+    {
+        // 当IP地址为IPv6时，其storage_id值为IP地址的short code
+        if (is_ipv6_addr(ip_addr))
+        {
+            fdfs_ip_to_shortcode(ip_addr, target_storage.id);
+        }
+        else
+        {
+            strcpy(target_storage.id, ip_addr);
+        }
+    }
 	else
 	{
 		FDFSStorageIdInfo *pStorageId;
@@ -3239,7 +3248,7 @@ static FDFSStorageDetail *tracker_mem_get_active_http_server_by_id( \
 FDFSStorageDetail *tracker_mem_get_storage_by_ip(FDFSGroupInfo *pGroup, \
 				const char *ip_addr)
 {
-	const char *storage_id;
+	FDFSStorageId storage_id;
 
 	if (g_use_storage_id)
 	{
@@ -3250,14 +3259,23 @@ FDFSStorageDetail *tracker_mem_get_storage_by_ip(FDFSGroupInfo *pGroup, \
 		{
 			return NULL;
 		}
-		storage_id = pStorageIdInfo->id;
+		storage_id.ptr = pStorageIdInfo->id;
 	}
 	else
-	{
-		storage_id = ip_addr;
-	}
+    {
+        // 当IP地址为IPv6时，其storage_id值为IP地址的short code
+        if (is_ipv6_addr(ip_addr))
+        {
+            storage_id.ptr = fdfs_ip_to_shortcode(ip_addr,
+                    storage_id.holder);
+        }
+        else
+        {
+            storage_id.ptr = (char *)ip_addr;
+        }
+    }
 
-	return tracker_mem_get_storage(pGroup, storage_id);
+	return tracker_mem_get_storage(pGroup, storage_id.ptr);
 }
 
 FDFSStorageDetail *tracker_mem_get_storage(FDFSGroupInfo *pGroup, \
@@ -3398,6 +3416,7 @@ int tracker_mem_delete_storage(FDFSGroupInfo *pGroup, const char *id)
 	FDFSStorageDetail *pStorageServer;
 	FDFSStorageDetail **ppServer;
 	FDFSStorageDetail **ppEnd;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
 	pStorageServer = tracker_mem_get_storage(pGroup, id);
 	if (pStorageServer == NULL || pStorageServer->status == \
@@ -3428,10 +3447,14 @@ int tracker_mem_delete_storage(FDFSGroupInfo *pGroup, const char *id)
 		}
 	}
 
-    logDebug("file: "__FILE__", line: %d, "
-            "delete storage server: %s:%u, group: %s",
-            __LINE__, pStorageServer->ip_addrs.ips[0].address,
-            pStorageServer->storage_port, pGroup->group_name);
+    if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
+        format_ip_address(pStorageServer->ip_addrs.
+                ips[0].address, formatted_ip);
+        logDebug("file: "__FILE__", line: %d, "
+                "delete storage server: %s:%u, group: %s", __LINE__,
+                formatted_ip, pStorageServer->storage_port,
+                pGroup->group_name);
+    }
 
 	tracker_mem_clear_storage_fields(pStorageServer);
 
@@ -3442,7 +3465,7 @@ int tracker_mem_delete_storage(FDFSGroupInfo *pGroup, const char *id)
 	return 0;
 }
 
-int tracker_mem_storage_ip_changed(FDFSGroupInfo *pGroup, \
+int tracker_mem_storage_ip_changed(FDFSGroupInfo *pGroup,
 		const char *old_storage_ip, const char *new_storage_ip)
 {
 	FDFSStorageDetail *pOldStorageServer;
@@ -3551,8 +3574,8 @@ static int tracker_mem_add_storage(TrackerClientInfo *pClientInfo,
 	FDFSStorageDetail *pStorageServer;
 
 	pStorageServer = NULL;
-	result = _tracker_mem_add_storage(pClientInfo->pGroup, \
-			&pStorageServer, id, ip_addr, bNeedSleep, \
+	result = _tracker_mem_add_storage(pClientInfo->pGroup,
+			&pStorageServer, id, ip_addr, bNeedSleep,
 			bNeedLock, bInserted);
 	if (result == 0)
 	{
@@ -3650,7 +3673,7 @@ static int _tracker_mem_add_storage(FDFSGroupInfo *pGroup,
 	const bool bNeedLock, bool *bInserted)
 {
 	int result;
-	const char *storage_id;
+	FDFSStorageId storage_id;
     FDFSStorageIdInfo *pStorageIdInfo;
     FDFSMultiIP multi_ip;
 
@@ -3698,7 +3721,7 @@ static int _tracker_mem_add_storage(FDFSGroupInfo *pGroup,
              multi_ip = pStorageIdInfo->ip_addrs;
 		}
 
-		storage_id = id;
+		storage_id.ptr = (char *)id;
 	}
 	else if (g_use_storage_id)
 	{
@@ -3714,11 +3737,19 @@ static int _tracker_mem_add_storage(FDFSGroupInfo *pGroup,
 		}
 
         multi_ip = pStorageIdInfo->ip_addrs;
-		storage_id = pStorageIdInfo->id;
+		storage_id.ptr = pStorageIdInfo->id;
 	}
 	else
 	{
-		storage_id = ip_addr;
+		// 当IP地址为IPv6时，其storage_id值为IP地址的short code
+		if (is_ipv6_addr(ip_addr))
+        {
+            storage_id.ptr = fdfs_ip_to_shortcode(ip_addr, storage_id.holder);
+        }
+        else
+        {
+            storage_id.ptr = (char *)ip_addr;
+        }
 	}
 
 	if (bNeedLock && (result=pthread_mutex_lock(&mem_thread_lock)) != 0)
@@ -3734,13 +3765,13 @@ static int _tracker_mem_add_storage(FDFSGroupInfo *pGroup,
 	{
 		result = 0;
 		*bInserted = false;
-		*ppStorageServer = tracker_mem_get_storage(pGroup, storage_id);
+		*ppStorageServer = tracker_mem_get_storage(pGroup, storage_id.ptr);
 		if (*ppStorageServer != NULL)
 		{
 			if (g_use_storage_id)
-			{
+            {
                 fdfs_set_multi_ip_index(&(*ppStorageServer)->ip_addrs, ip_addr);
-			}
+            }
 
 			if ((*ppStorageServer)->status==FDFS_STORAGE_STATUS_DELETED \
 			 || (*ppStorageServer)->status==FDFS_STORAGE_STATUS_IP_CHANGED)
@@ -3763,7 +3794,7 @@ static int _tracker_mem_add_storage(FDFSGroupInfo *pGroup,
 
 		*ppStorageServer = *(pGroup->all_servers + pGroup->count);
 		snprintf((*ppStorageServer)->id, FDFS_STORAGE_ID_MAX_SIZE,
-				"%s", storage_id);
+				"%s", storage_id.ptr);
         (*ppStorageServer)->ip_addrs = multi_ip;
         if (g_use_storage_id)
         {
@@ -3815,6 +3846,7 @@ static int tracker_mem_get_sys_file_piece(ConnectionInfo *pTrackerServer, \
 {
 	char out_buff[sizeof(TrackerHeader) + 1 + FDFS_PROTO_PKG_LEN_SIZE];
 	char in_buff[TRACKER_MAX_PACKAGE_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	TrackerHeader *pHeader;
 	char *p;
 	char *pInBuff;
@@ -3834,13 +3866,12 @@ static int tracker_mem_get_sys_file_piece(ConnectionInfo *pTrackerServer, \
 	if ((result=tcpsenddata_nb(pTrackerServer->sock, out_buff, \
 			sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"send data to tracker server %s:%u fail, " \
-			"errno: %d, error info: %s", __LINE__, \
-			pTrackerServer->ip_addr, \
-			pTrackerServer->port, \
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"send data to tracker server %s:%u fail, "
+			"errno: %d, error info: %s", __LINE__,
+            formatted_ip, pTrackerServer->port,
 			result, STRERROR(result));
-
 		return (result == ENOENT ? EACCES : result);
 	}
 
@@ -3857,11 +3888,12 @@ static int tracker_mem_get_sys_file_piece(ConnectionInfo *pTrackerServer, \
 
 	if (in_bytes < FDFS_PROTO_PKG_LEN_SIZE)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u response data " \
-			"length: %"PRId64" is invalid, " \
-			"expect length >= %d.", __LINE__, \
-			pTrackerServer->ip_addr, pTrackerServer->port, \
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u response data "
+			"length: %"PRId64" is invalid, "
+			"expect length >= %d.", __LINE__,
+			formatted_ip, pTrackerServer->port,
 			in_bytes, FDFS_PROTO_PKG_LEN_SIZE);
 		return EINVAL;
 	}
@@ -3871,20 +3903,21 @@ static int tracker_mem_get_sys_file_piece(ConnectionInfo *pTrackerServer, \
 
 	if (*file_size < 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u, file size: %"PRId64\
-			" < 0", __LINE__, pTrackerServer->ip_addr, \
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u, file size: %"PRId64
+			" < 0", __LINE__, formatted_ip,
 			pTrackerServer->port, *file_size);
 		return EINVAL;
 	}
 
 	if (*file_size > 0 && write_bytes == 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u, file size: %"PRId64\
-			" > 0, but file content is empty", __LINE__, \
-			pTrackerServer->ip_addr, pTrackerServer->port, \
-			*file_size);
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server %s:%u, file size: %"PRId64
+			" > 0, but file content is empty", __LINE__,
+			formatted_ip, pTrackerServer->port, *file_size);
 		return EINVAL;
 	}
 
@@ -4243,6 +4276,7 @@ static int tracker_mem_get_tracker_server(FDFSStorageJoinBody *pJoinBody, \
 	TrackerServerInfo *pTrackerEnd;
 	TrackerRunningStatus *pStatus;
 	TrackerRunningStatus trackerStatus[FDFS_MAX_TRACKERS];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	int count;
 	int result;
 	int r;
@@ -4284,17 +4318,20 @@ static int tracker_mem_get_tracker_server(FDFSStorageJoinBody *pJoinBody, \
 			tracker_mem_cmp_tracker_running_status);
 	}
 
-	for (i=0; i<count; i++)
-	{
-		logDebug("file: "__FILE__", line: %d, "
-			"%s:%u leader: %d, running time: %d, "
-			"restart interval: %d", __LINE__,
-			trackerStatus[i].pTrackerServer->connections[0].ip_addr,
-			trackerStatus[i].pTrackerServer->connections[0].port,
-			trackerStatus[i].if_leader,
-			trackerStatus[i].running_time,
-			trackerStatus[i].restart_interval);
-	}
+    if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
+        for (i=0; i<count; i++)
+        {
+            format_ip_address(trackerStatus[i].pTrackerServer->
+                    connections[0].ip_addr, formatted_ip);
+            logDebug("file: "__FILE__", line: %d, "
+                    "%s:%u leader: %d, running time: %d, "
+                    "restart interval: %d", __LINE__, formatted_ip,
+                    trackerStatus[i].pTrackerServer->connections[0].port,
+                    trackerStatus[i].if_leader,
+                    trackerStatus[i].running_time,
+                    trackerStatus[i].restart_interval);
+        }
+    }
 
 	//copy the last
 	memcpy(pTrackerStatus, trackerStatus + (count - 1), \
@@ -4310,6 +4347,7 @@ static int tracker_mem_get_sys_files_from_others(FDFSStorageJoinBody *pJoinBody,
 	TrackerServerInfo *pTrackerServer;
 	FDFSGroups newGroups;
 	FDFSGroups tempGroups;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
 	if (pJoinBody->tracker_count == 0)
 	{
@@ -4327,11 +4365,12 @@ static int tracker_mem_get_sys_files_from_others(FDFSStorageJoinBody *pJoinBody,
 		if (tracker_mem_cmp_tracker_running_status(pRunningStatus,
 							&trackerStatus) >= 0)
 		{
+            format_ip_address(trackerStatus.pTrackerServer->
+                    connections[0].ip_addr, formatted_ip);
 			logDebug("file: "__FILE__", line: %d, "
 				"%s:%u running time: %d, restart interval: %d, "
 				"my running time: %d, restart interval: %d, "
-				"do not need sync system files", __LINE__,
-				trackerStatus.pTrackerServer->connections[0].ip_addr,
+				"do not need sync system files", __LINE__, formatted_ip,
 				trackerStatus.pTrackerServer->connections[0].port,
 				trackerStatus.running_time,
 				trackerStatus.restart_interval,
@@ -4349,10 +4388,10 @@ static int tracker_mem_get_sys_files_from_others(FDFSStorageJoinBody *pJoinBody,
 		return result;
 	}
 
+    format_ip_address(pTrackerServer->connections[0].ip_addr, formatted_ip);
 	logInfo("file: "__FILE__", line: %d, "
-		"sys files loaded from tracker server %s:%u",
-		__LINE__, pTrackerServer->connections[0].ip_addr,
-		pTrackerServer->connections[0].port);
+		"sys files loaded from tracker server %s:%u", __LINE__,
+        formatted_ip, pTrackerServer->connections[0].port);
 
 	memset(&newGroups, 0, sizeof(newGroups));
 	newGroups.store_lookup = g_groups.store_lookup;
@@ -4383,8 +4422,8 @@ static int tracker_mem_get_sys_files_from_others(FDFSStorageJoinBody *pJoinBody,
 	return tracker_open_changlog_file();
 }
 
-int tracker_mem_add_group_and_storage(TrackerClientInfo *pClientInfo, \
-		const char *ip_addr, FDFSStorageJoinBody *pJoinBody, \
+int tracker_mem_add_group_and_storage(TrackerClientInfo *pClientInfo,
+		const char *ip_addr, FDFSStorageJoinBody *pJoinBody,
 		const bool bNeedSleep)
 {
 	int result;
@@ -4393,8 +4432,8 @@ int tracker_mem_add_group_and_storage(TrackerClientInfo *pClientInfo, \
 	FDFSStorageDetail *pStorageServer;
 	FDFSStorageDetail **ppServer;
 	FDFSStorageDetail **ppEnd;
-	FDFSStorageIdInfo *pStorageIdInfo;
-	const char *storage_id;
+	FDFSStorageId storage_id;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
 	tracker_mem_file_lock();
 
@@ -4464,7 +4503,7 @@ int tracker_mem_add_group_and_storage(TrackerClientInfo *pClientInfo, \
 
 	tracker_mem_file_unlock();
 
-	if ((result=tracker_mem_add_group_ex(&g_groups, pClientInfo, \
+	if ((result=tracker_mem_add_group_ex(&g_groups, pClientInfo,
 		pJoinBody->group_name, bNeedSleep, &bGroupInserted)) != 0)
 	{
 		return result;
@@ -4480,22 +4519,45 @@ int tracker_mem_add_group_and_storage(TrackerClientInfo *pClientInfo, \
 
 	if (g_use_storage_id)
 	{
-		pStorageIdInfo = fdfs_get_storage_id_by_ip(
-				pClientInfo->pGroup->group_name, ip_addr);
-		if (pStorageIdInfo == NULL)
-		{
-			logError("file: "__FILE__", line: %d, " \
-				"get storage id info fail, group_name: %s, " \
-				"storage ip: %s", __LINE__, \
-				pClientInfo->pGroup->group_name, ip_addr);
-			return ENOENT;
-		}
-		storage_id = pStorageIdInfo->id;
+        FDFSStorageIdInfo *pStorageIdInfo;
+
+        if (g_trust_storage_server_id && *(pJoinBody->storage_id) != '\0')
+        {
+            pStorageIdInfo = fdfs_get_storage_by_id(pJoinBody->storage_id);
+            if (pStorageIdInfo == NULL)
+            {
+                logError("file: "__FILE__", line: %d, "
+                        "get storage id info fail, storage id: %s",
+                        __LINE__, pJoinBody->storage_id);
+                return ENOENT;
+            }
+        }
+        else
+        {
+            pStorageIdInfo = fdfs_get_storage_id_by_ip(
+                    pClientInfo->pGroup->group_name, ip_addr);
+            if (pStorageIdInfo == NULL)
+            {
+                logError("file: "__FILE__", line: %d, "
+                        "get storage id info fail, group_name: %s, "
+                        "storage ip: %s", __LINE__,
+                        pClientInfo->pGroup->group_name, ip_addr);
+                return ENOENT;
+            }
+        }
+		storage_id.ptr = pStorageIdInfo->id;
 	}
 	else
 	{
-		pStorageIdInfo = NULL;
-		storage_id = ip_addr;
+		// 当IP地址为IPv6时，其storage_id值为IP地址的short code
+		if (is_ipv6_addr(ip_addr))
+        {
+            storage_id.ptr = fdfs_ip_to_shortcode(ip_addr, storage_id.holder);
+		}
+        else
+        {
+            storage_id.ptr = (char *)ip_addr;
+        }
 	}
 
 	if (pClientInfo->pGroup->storage_port == 0)
@@ -4516,7 +4578,7 @@ int tracker_mem_add_group_and_storage(TrackerClientInfo *pClientInfo, \
 			for (ppServer=pClientInfo->pGroup->all_servers; \
 				ppServer<ppEnd; ppServer++)
 			{
-				if (strcmp((*ppServer)->id, storage_id) == 0)
+				if (strcmp((*ppServer)->id, storage_id.ptr) == 0)
 				{
 					(*ppServer)->storage_port = \
 						pJoinBody->storage_port;
@@ -4574,7 +4636,7 @@ int tracker_mem_add_group_and_storage(TrackerClientInfo *pClientInfo, \
 			for (ppServer=pClientInfo->pGroup->all_servers; \
 				ppServer<ppEnd; ppServer++)
 			{
-				if (strcmp((*ppServer)->id, storage_id) == 0)
+				if (strcmp((*ppServer)->id, storage_id.ptr) == 0)
 				{
 					(*ppServer)->storage_http_port = \
 						pJoinBody->storage_http_port;
@@ -4624,7 +4686,8 @@ int tracker_mem_add_group_and_storage(TrackerClientInfo *pClientInfo, \
 			__LINE__, result, STRERROR(result));
 		return result;
 	}
-	pStorageServer = tracker_mem_get_storage(pClientInfo->pGroup, storage_id);
+	pStorageServer = tracker_mem_get_storage(pClientInfo->pGroup,
+            storage_id.ptr);
 	if (pthread_mutex_unlock(&mem_thread_lock) != 0)
 	{
 		logError("file: "__FILE__", line: %d, "   \
@@ -4641,20 +4704,21 @@ int tracker_mem_add_group_and_storage(TrackerClientInfo *pClientInfo, \
 			pJoinBody->status == FDFS_STORAGE_STATUS_IP_CHANGED || \
 			pJoinBody->status == FDFS_STORAGE_STATUS_NONE)
 			{
-				logError("file: "__FILE__", line: %d, " \
-					"client ip: %s:%u, invalid storage " \
-					"status %d, in the group \"%s\"", \
-					__LINE__, ip_addr, \
-					pJoinBody->storage_port, \
-					pJoinBody->status, \
+                format_ip_address(ip_addr, formatted_ip);
+				logError("file: "__FILE__", line: %d, "
+					"client ip: %s:%u, invalid storage "
+					"status %d, in the group \"%s\"",
+					__LINE__, formatted_ip,
+					pJoinBody->storage_port,
+					pJoinBody->status,
 					pJoinBody->group_name);
 				return EFAULT;
 			}
 		}
 	}
 
-	if ((result=tracker_mem_add_storage(pClientInfo, storage_id, ip_addr,
-			bNeedSleep, true, &bStorageInserted)) != 0)
+	if ((result=tracker_mem_add_storage(pClientInfo, storage_id.ptr,
+                    ip_addr, bNeedSleep, true, &bStorageInserted)) != 0)
 	{
 		return result;
 	}
@@ -4843,6 +4907,7 @@ int tracker_mem_sync_storages(FDFSGroupInfo *pGroup, \
 	FDFSStorageDetail target_storage;
 	FDFSStorageDetail *pTargetStorage;
 	FDFSStorageDetail **ppFound;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
 	if ((result=pthread_mutex_lock(&mem_thread_lock)) != 0)
 	{
@@ -4890,11 +4955,12 @@ int tracker_mem_sync_storages(FDFSGroupInfo *pGroup, \
 					continue;
 				}
 
+                format_ip_address(FDFS_CURRENT_IP_ADDR(*ppFound),
+                        formatted_ip);
                 logWarning("file: "__FILE__", line: %d, "
                         "storage server: %s:%u, dest status: %d, "
                         "my status: %d, should change my status!",
-                        __LINE__, FDFS_CURRENT_IP_ADDR(*ppFound),
-                        (*ppFound)->storage_port,
+                        __LINE__, formatted_ip, (*ppFound)->storage_port,
                         pServer->status, (*ppFound)->status);
 
 				if (pServer->status == \
@@ -4988,6 +5054,7 @@ static int _storage_get_trunk_binlog_size(
 	ConnectionInfo *pStorageServer, int64_t *file_size)
 {
 	char out_buff[sizeof(TrackerHeader)];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char in_buff[8];
 	TrackerHeader *pHeader;
 	char *pInBuff;
@@ -5000,11 +5067,11 @@ static int _storage_get_trunk_binlog_size(
 	if ((result=tcpsenddata_nb(pStorageServer->sock, out_buff, \
 			sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"storage server %s:%u, send data fail, " \
-			"errno: %d, error info: %s.", \
-			__LINE__, pStorageServer->ip_addr, \
-			pStorageServer->port, \
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"storage server %s:%u, send data fail, "
+			"errno: %d, error info: %s.", __LINE__,
+            formatted_ip, pStorageServer->port,
 			result, STRERROR(result));
 		return result;
 	}
@@ -5021,10 +5088,10 @@ static int _storage_get_trunk_binlog_size(
 
 	if (in_bytes != sizeof(in_buff))
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"storage server %s:%u, recv body length: " \
-			"%"PRId64" != %d",  \
-			__LINE__, pStorageServer->ip_addr, \
+        format_ip_address(pStorageServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"storage server %s:%u, recv body length: "
+			"%"PRId64" != %d", __LINE__, formatted_ip,
 			pStorageServer->port, in_bytes, (int)sizeof(in_buff));
 		return EINVAL;
 	}
@@ -5038,6 +5105,7 @@ static int tracker_mem_get_trunk_binlog_size(
 {
 	ConnectionInfo storage_server;
 	ConnectionInfo *conn;
+    char formatted_ip[FORMATTED_IP_SIZE];
 	int result;
 
 	*file_size = 0;
@@ -5052,11 +5120,13 @@ static int tracker_mem_get_trunk_binlog_size(
 	result = _storage_get_trunk_binlog_size(conn, file_size);
 	tracker_close_connection_ex(conn, result != 0);
 
+    if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
+        format_ip_address(storage_server.ip_addr, formatted_ip);
+        logDebug("file: "__FILE__", line: %d, "
+                "storage %s:%u, trunk binlog file size: %"PRId64,
+                __LINE__, formatted_ip, storage_server.port, *file_size);
+    }
 
-	logDebug("file: "__FILE__", line: %d, " \
-		"storage %s:%u, trunk binlog file size: %"PRId64, \
-		__LINE__, storage_server.ip_addr, storage_server.port, \
-		*file_size);
 	return result;
 }
 
@@ -5192,6 +5262,7 @@ static int tracker_set_trunk_server_and_log(FDFSGroupInfo *pGroup, \
 static int tracker_mem_do_set_trunk_server(FDFSGroupInfo *pGroup, 
 	FDFSStorageDetail *pTrunkServer, const bool save)
 {
+    char formatted_ip[FORMATTED_IP_SIZE];
 	int result;
 
 	if (*(pGroup->last_trunk_server_id) != '\0' && 
@@ -5213,11 +5284,12 @@ static int tracker_mem_do_set_trunk_server(FDFSGroupInfo *pGroup,
 	pGroup->trunk_chg_count++;
 	g_trunk_server_chg_count++;
 
+    format_ip_address(FDFS_CURRENT_IP_ADDR(pGroup->
+                pTrunkServer), formatted_ip);
 	logInfo("file: "__FILE__", line: %d, "
 		"group: %s, trunk server set to %s(%s:%u)", __LINE__,
 		pGroup->group_name, pGroup->pTrunkServer->id,
-		FDFS_CURRENT_IP_ADDR(pGroup->pTrunkServer),
-        pGroup->storage_port);
+        formatted_ip, pGroup->storage_port);
 	if (save)
 	{
 		return tracker_save_groups();
@@ -5649,7 +5721,7 @@ int tracker_mem_get_storage_by_filename(const byte cmd,FDFS_DOWNLOAD_TYPE_PARAM\
 		char name_buff[64];
 		int decoded_len;
 
-		base64_decode_auto(&g_base64_context, (char *)filename + \
+		base64_decode_auto(&g_fdfs_base64_context, (char *)filename + \
 			FDFS_LOGIC_FILE_PATH_LEN, FDFS_FILENAME_BASE64_LENGTH, \
 			name_buff, &decoded_len);
 		storage_ip = ntohl(buff2int(name_buff));
@@ -6060,6 +6132,7 @@ int tracker_mem_check_alive(void *arg)
 	FDFSGroupInfo **ppGroup;
 	FDFSGroupInfo **ppGroupEnd;
 	FDFSStorageDetail *deactiveServers[FDFS_MAX_SERVERS_EACH_GROUP];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	int deactiveCount;
 	time_t current_time;
 
@@ -6091,6 +6164,7 @@ int tracker_mem_check_alive(void *arg)
 	ppServerEnd = deactiveServers + deactiveCount;
 	for (ppServer=deactiveServers; ppServer<ppServerEnd; ppServer++)
 	{
+        format_ip_address(FDFS_CURRENT_IP_ADDR(*ppServer), formatted_ip);
 		(*ppServer)->status = FDFS_STORAGE_STATUS_OFFLINE;
 		tracker_mem_deactive_store_server(*ppGroup, *ppServer);
 		if (g_use_storage_id)
@@ -6098,7 +6172,7 @@ int tracker_mem_check_alive(void *arg)
 			logInfo("file: "__FILE__", line: %d, "
 				"storage server %s(%s:%u) idle too long, "
 				"status change to offline!", __LINE__,
-				(*ppServer)->id, FDFS_CURRENT_IP_ADDR(*ppServer),
+				(*ppServer)->id, formatted_ip,
 				(*ppGroup)->storage_port);
 		}
 		else
@@ -6106,8 +6180,7 @@ int tracker_mem_check_alive(void *arg)
 			logInfo("file: "__FILE__", line: %d, "
 				"storage server %s:%u idle too long, "
 				"status change to offline!", __LINE__,
-				FDFS_CURRENT_IP_ADDR(*ppServer),
-                (*ppGroup)->storage_port);
+                formatted_ip, (*ppGroup)->storage_port);
 		}
 	}
 	}
@@ -6153,12 +6226,13 @@ int tracker_mem_check_alive(void *arg)
 					g_check_active_interval;
 	    	if (last_beat_interval > check_trunk_interval)
 		{
+            format_ip_address(FDFS_CURRENT_IP_ADDR((*ppGroup)->
+                        pTrunkServer), formatted_ip);
 			logInfo("file: "__FILE__", line: %d, "
 				"trunk server %s(%s:%u) offline because idle "
 				"time: %d s > threshold: %d s, should "
 				"re-select trunk server", __LINE__,
-				(*ppGroup)->pTrunkServer->id,
-				FDFS_CURRENT_IP_ADDR((*ppGroup)->pTrunkServer),
+				(*ppGroup)->pTrunkServer->id, formatted_ip,
 				(*ppGroup)->storage_port, last_beat_interval,
 				check_trunk_interval);
 

tracker/tracker_mem.h

@@ -59,16 +59,16 @@ FDFSStorageDetail *tracker_mem_get_storage(FDFSGroupInfo *pGroup, \
 FDFSStorageDetail *tracker_mem_get_storage_by_ip(FDFSGroupInfo *pGroup, \
 				const char *ip_addr);
 
-const FDFSStorageDetail *tracker_mem_set_trunk_server( \
+const FDFSStorageDetail *tracker_mem_set_trunk_server(
 	FDFSGroupInfo *pGroup, const char *pStroageId, int *result);
 int tracker_mem_delete_group(const char *group_name);
 int tracker_mem_delete_storage(FDFSGroupInfo *pGroup, const char *id);
 
-int tracker_mem_storage_ip_changed(FDFSGroupInfo *pGroup, \
+int tracker_mem_storage_ip_changed(FDFSGroupInfo *pGroup,
 		const char *old_storage_ip, const char *new_storage_ip);
 
-int tracker_mem_add_group_and_storage(TrackerClientInfo *pClientInfo, \
-		const char *ip_addr, FDFSStorageJoinBody *pJoinBody, \
+int tracker_mem_add_group_and_storage(TrackerClientInfo *pClientInfo,
+		const char *ip_addr, FDFSStorageJoinBody *pJoinBody,
 		const bool bNeedSleep);
 
 int tracker_mem_offline_store_server(FDFSGroupInfo *pGroup, \

tracker/tracker_proto.c

@@ -43,27 +43,27 @@ int fdfs_recv_header_ex(ConnectionInfo *pTrackerServer,
         const int network_timeout, int64_t *in_bytes)
 {
 	TrackerHeader resp;
+    char formatted_ip[FORMATTED_IP_SIZE];
 	int result;
 
 	if ((result=tcprecvdata_nb(pTrackerServer->sock, &resp,
 		sizeof(resp), network_timeout)) != 0)
-	{
-		logError("file: "__FILE__", line: %d, "
-			"server: %s:%u, recv data fail, "
-			"errno: %d, error info: %s",
-			__LINE__, pTrackerServer->ip_addr,
-			pTrackerServer->port,
-			result, STRERROR(result));
-		*in_bytes = 0;
-		return result;
-	}
+    {
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+        logError("file: "__FILE__", line: %d, "
+                "server: %s:%u, recv data fail, errno: %d, error info: %s",
+                __LINE__, formatted_ip, pTrackerServer->port,
+                result, STRERROR(result));
+        *in_bytes = 0;
+        return result;
+    }
 
 	if (resp.status != 0)
 	{
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
 		logError("file: "__FILE__", line: %d, "
-			"server: %s:%u, response status %d != 0",
-			__LINE__, pTrackerServer->ip_addr,
-			pTrackerServer->port, resp.status);
+			"server: %s:%u, response status %d != 0", __LINE__,
+            formatted_ip, pTrackerServer->port, resp.status);
 
 		*in_bytes = 0;
 		return resp.status;
@@ -71,15 +71,14 @@ int fdfs_recv_header_ex(ConnectionInfo *pTrackerServer,
 
 	*in_bytes = buff2long(resp.pkg_len);
 	if (*in_bytes < 0)
-	{
-		logError("file: "__FILE__", line: %d, "
-			"server: %s:%u, recv package size "
-			"%"PRId64" is not correct",
-			__LINE__, pTrackerServer->ip_addr,
-			pTrackerServer->port, *in_bytes);
-		*in_bytes = 0;
-		return EINVAL;
-	}
+    {
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+        logError("file: "__FILE__", line: %d, "
+                "server: %s:%u, recv package size %"PRId64" is not correct",
+                __LINE__, formatted_ip, pTrackerServer->port, *in_bytes);
+        *in_bytes = 0;
+        return EINVAL;
+    }
 
 	return resp.status;
 }
@@ -90,6 +89,7 @@ int fdfs_recv_response(ConnectionInfo *pTrackerServer, \
 {
 	int result;
 	bool bMalloced;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
 	result = fdfs_recv_header(pTrackerServer, in_bytes);
 	if (result != 0)
@@ -120,36 +120,35 @@ int fdfs_recv_response(ConnectionInfo *pTrackerServer, \
 	else 
 	{
 		if (*in_bytes > buff_size)
-		{
-			logError("file: "__FILE__", line: %d, " \
-				"server: %s:%u, recv body bytes: " \
-				"%"PRId64" exceed max: %d", \
-				__LINE__, pTrackerServer->ip_addr, \
-				pTrackerServer->port, *in_bytes, buff_size);
-			*in_bytes = 0;
-			return ENOSPC;
-		}
+        {
+            format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+            logError("file: "__FILE__", line: %d, "
+                    "server: %s:%u, recv body bytes: %"PRId64" exceed "
+                    "max: %d", __LINE__, formatted_ip, pTrackerServer->port,
+                    *in_bytes, buff_size);
+            *in_bytes = 0;
+            return ENOSPC;
+        }
 
 		bMalloced = false;
 	}
 
-	if ((result=tcprecvdata_nb(pTrackerServer->sock, *buff, \
+	if ((result=tcprecvdata_nb(pTrackerServer->sock, *buff,
 		*in_bytes, SF_G_NETWORK_TIMEOUT)) != 0)
-	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server: %s:%u, recv data fail, " \
-			"errno: %d, error info: %s", \
-			__LINE__, pTrackerServer->ip_addr, \
-			pTrackerServer->port, \
-			result, STRERROR(result));
-		*in_bytes = 0;
-		if (bMalloced)
-		{
-			free(*buff);
-			*buff = NULL;
-		}
-		return result;
-	}
+    {
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+        logError("file: "__FILE__", line: %d, "
+                "tracker server: %s:%u, recv data fail, errno: %d, "
+                "error info: %s", __LINE__, formatted_ip,
+                pTrackerServer->port, result, STRERROR(result));
+        *in_bytes = 0;
+        if (bMalloced)
+        {
+            free(*buff);
+            *buff = NULL;
+        }
+        return result;
+    }
 
 	return 0;
 }
@@ -157,20 +156,20 @@ int fdfs_recv_response(ConnectionInfo *pTrackerServer, \
 int fdfs_quit(ConnectionInfo *pTrackerServer)
 {
 	TrackerHeader header;
+    char formatted_ip[FORMATTED_IP_SIZE];
 	int result;
 
 	memset(&header, 0, sizeof(header));
 	header.cmd = FDFS_PROTO_CMD_QUIT;
-	result = tcpsenddata_nb(pTrackerServer->sock, &header, \
+	result = tcpsenddata_nb(pTrackerServer->sock, &header,
 			sizeof(header), SF_G_NETWORK_TIMEOUT);
 	if(result != 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server: %s:%u, send data fail, " \
-			"errno: %d, error info: %s", \
-			__LINE__, pTrackerServer->ip_addr, \
-			pTrackerServer->port, \
-			result, STRERROR(result));
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"tracker server: %s:%u, send data fail, errno: %d, "
+            "error info: %s", __LINE__, formatted_ip,
+			pTrackerServer->port, result, STRERROR(result));
 		return result;
 	}
 
@@ -488,7 +487,8 @@ ConnectionInfo *tracker_connect_server_ex(TrackerServerInfo *pServerInfo,
 }
 
 ConnectionInfo *tracker_connect_server_no_pool_ex(TrackerServerInfo *pServerInfo,
-        const char *bind_addr, int *err_no, const bool log_connect_error)
+        const char *bind_addr4, const char *bind_addr6, int *err_no,
+        const bool log_connect_error)
 {
 	ConnectionInfo *conn;
 	ConnectionInfo *end;
@@ -500,12 +500,12 @@ ConnectionInfo *tracker_connect_server_no_pool_ex(TrackerServerInfo *pServerInfo
 		return pServerInfo->connections + pServerInfo->index;
 	}
 
-	*err_no = conn_pool_connect_server_ex(pServerInfo->connections
-            + pServerInfo->index, SF_G_CONNECT_TIMEOUT * 1000,
-            bind_addr, log_connect_error);
+    conn = pServerInfo->connections + pServerInfo->index;
+	*err_no = conn_pool_connect_server_ex(conn, SF_G_CONNECT_TIMEOUT * 1000,
+            conn->af == AF_INET ? bind_addr4 : bind_addr6, log_connect_error);
     if (*err_no == 0)
     {
-		return pServerInfo->connections + pServerInfo->index;
+        return conn;
     }
 
     if (pServerInfo->count == 1)
@@ -520,11 +520,12 @@ ConnectionInfo *tracker_connect_server_no_pool_ex(TrackerServerInfo *pServerInfo
         if (current_index != pServerInfo->index)
         {
             if ((*err_no=conn_pool_connect_server_ex(conn,
-                            SF_G_CONNECT_TIMEOUT * 1000, bind_addr,
-                            log_connect_error)) == 0)
+                            SF_G_CONNECT_TIMEOUT * 1000,
+                            conn->af == AF_INET ? bind_addr4 :
+                            bind_addr6, log_connect_error)) == 0)
             {
                 pServerInfo->index = current_index;
-                return pServerInfo->connections + pServerInfo->index;
+                return conn;
             }
         }
     }
@@ -590,52 +591,55 @@ void tracker_disconnect_server_no_pool(TrackerServerInfo *pServerInfo)
     }
 }
 
-static int fdfs_do_parameter_req(ConnectionInfo *pTrackerServer, \
-	char *buff, const int buff_size)
+static int fdfs_do_parameter_req(ConnectionInfo *pTrackerServer,
+        char *buff, const int buff_size)
 {
-	char out_buff[sizeof(TrackerHeader)];
-	TrackerHeader *pHeader;
-	int64_t in_bytes;
-	int result;
+    char out_buff[sizeof(TrackerHeader)];
+    char formatted_ip[FORMATTED_IP_SIZE];
+    TrackerHeader *pHeader;
+    int64_t in_bytes;
+    int result;
 
-	memset(out_buff, 0, sizeof(out_buff));
-	pHeader = (TrackerHeader *)out_buff;
-	pHeader->cmd = TRACKER_PROTO_CMD_STORAGE_PARAMETER_REQ;
-	if((result=tcpsenddata_nb(pTrackerServer->sock, out_buff, \
-		sizeof(TrackerHeader), SF_G_NETWORK_TIMEOUT)) != 0)
-	{
-		logError("file: "__FILE__", line: %d, " \
-			"tracker server %s:%u, send data fail, " \
-			"errno: %d, error info: %s.", \
-			__LINE__, pTrackerServer->ip_addr, \
-			pTrackerServer->port, \
-			result, STRERROR(result));
-		return result;
-	}
+    memset(out_buff, 0, sizeof(out_buff));
+    pHeader = (TrackerHeader *)out_buff;
+    pHeader->cmd = TRACKER_PROTO_CMD_STORAGE_PARAMETER_REQ;
+    if((result=tcpsenddata_nb(pTrackerServer->sock, out_buff,
+                    sizeof(TrackerHeader), SF_G_NETWORK_TIMEOUT)) != 0)
+    {
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+        logError("file: "__FILE__", line: %d, "
+                "tracker server %s:%u, send data fail, "
+                "errno: %d, error info: %s", __LINE__,
+                formatted_ip, pTrackerServer->port,
+                result, STRERROR(result));
+        return result;
+    }
 
-	result = fdfs_recv_response(pTrackerServer, &buff, buff_size, &in_bytes);
-	if (result != 0)
-	{
-		return result;
-	}
+    result = fdfs_recv_response(pTrackerServer, &buff, buff_size, &in_bytes);
+    if (result != 0)
+    {
+        return result;
+    }
 
-	if (in_bytes >= buff_size)
-	{
-		logError("file: "__FILE__", line: %d, " \
-			"server: %s:%u, recv body bytes: " \
-			"%"PRId64" exceed max: %d", \
-			__LINE__, pTrackerServer->ip_addr, \
-			pTrackerServer->port, in_bytes, buff_size);
-		return ENOSPC;
-	}
+    if (in_bytes >= buff_size)
+    {
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
+        logError("file: "__FILE__", line: %d, "
+                "server: %s:%u, recv body bytes: "
+                "%"PRId64" exceed max: %d", __LINE__,
+                formatted_ip, pTrackerServer->port,
+                in_bytes, buff_size);
+        return ENOSPC;
+    }
 
-	*(buff + in_bytes) = '\0';
-	return 0;
+    *(buff + in_bytes) = '\0';
+    return 0;
 }
 
-int fdfs_get_ini_context_from_tracker(TrackerServerGroup *pTrackerGroup, \
-		IniContext *iniContext, bool * volatile continue_flag, \
-		const bool client_bind_addr, const char *bind_addr)
+int fdfs_get_ini_context_from_tracker_ex(TrackerServerGroup *pTrackerGroup,
+                IniContext *iniContext, bool * volatile continue_flag,
+                const bool client_bind_addr, const char *bind_addr4,
+                const char *bind_addr6)
 {
     ConnectionInfo *conn;
 	TrackerServerInfo *pGlobalServer;
@@ -644,6 +648,7 @@ int fdfs_get_ini_context_from_tracker(TrackerServerGroup *pTrackerGroup, \
 	TrackerServerInfo *pTServer;
 	TrackerServerInfo trackerServer;
 	char in_buff[1024];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	int result;
 	int leader_index;
 	int i;
@@ -664,7 +669,14 @@ int fdfs_get_ini_context_from_tracker(TrackerServerGroup *pTrackerGroup, \
 
     if (!client_bind_addr)
     {
-        bind_addr = NULL;
+        if (bind_addr4 != NULL)
+        {
+            bind_addr4 = NULL;
+        }
+        if (bind_addr6 != NULL)
+        {
+            bind_addr6 = NULL;
+        }
     }
 
 	do
@@ -678,7 +690,7 @@ int fdfs_get_ini_context_from_tracker(TrackerServerGroup *pTrackerGroup, \
             for (i=0; i < 3; i++)
             {
                 conn = tracker_connect_server_no_pool_ex(pTServer,
-                        bind_addr, &result, false);
+                        bind_addr4, bind_addr6, &result, false);
                 if (conn != NULL)
                 {
                     break;
@@ -689,11 +701,13 @@ int fdfs_get_ini_context_from_tracker(TrackerServerGroup *pTrackerGroup, \
 
             if (conn == NULL)
             {
+                format_ip_address(pTServer->connections[0].
+                        ip_addr, formatted_ip);
                 logError("file: "__FILE__", line: %d, "
                         "connect to server %s:%u fail, errno: %d, "
-                        "error info: %s", __LINE__, pTServer->connections[0].
-                        ip_addr, pTServer->connections[0].port,
-                        result, STRERROR(result));
+                        "error info: %s", __LINE__, formatted_ip,
+                        pTServer->connections[0].port, result,
+                        STRERROR(result));
                 continue;
             }
 
@@ -706,9 +720,10 @@ int fdfs_get_ini_context_from_tracker(TrackerServerGroup *pTrackerGroup, \
                 return result;
             }
 
+            format_ip_address(conn->ip_addr, formatted_ip);
             logError("file: "__FILE__", line: %d, "
                     "get parameters from tracker server %s:%u fail",
-                    __LINE__, conn->ip_addr, conn->port);
+                    __LINE__, formatted_ip, conn->port);
             close(conn->sock);
             sleep(1);
         }
@@ -726,6 +741,7 @@ int fdfs_get_tracker_status(TrackerServerInfo *pTrackerServer,
 		TrackerRunningStatus *pStatus)
 {
 	char in_buff[1 + 2 * FDFS_PROTO_PKG_LEN_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	TrackerHeader header;
 	char *pInBuff;
 	ConnectionInfo *conn;
@@ -745,10 +761,10 @@ int fdfs_get_tracker_status(TrackerServerInfo *pTrackerServer,
 	if ((result=tcpsenddata_nb(conn->sock, &header,
 			sizeof(header), SF_G_NETWORK_TIMEOUT)) != 0)
 	{
+        format_ip_address(conn->ip_addr, formatted_ip);
 		logError("file: "__FILE__", line: %d, "
-			"send data to tracker server %s:%u fail, "
-			"errno: %d, error info: %s", __LINE__,
-			conn->ip_addr, conn->port,
+			"send data to tracker server %s:%u fail, errno: %d, "
+			"error info: %s", __LINE__, formatted_ip, conn->port,
 			result, STRERROR(result));
 
 		result = (result == ENOENT ? EACCES : result);
@@ -765,11 +781,11 @@ int fdfs_get_tracker_status(TrackerServerInfo *pTrackerServer,
 
 	if (in_bytes != sizeof(in_buff))
 	{
+        format_ip_address(conn->ip_addr, formatted_ip);
 		logError("file: "__FILE__", line: %d, "
-			"tracker server %s:%u response data "
-			"length: %"PRId64" is invalid, "
-			"expect length: %d.", __LINE__,
-			conn->ip_addr, conn->port,
+			"tracker server %s:%u response data length: "
+			"%"PRId64" is invalid, expect length: %d",
+            __LINE__, formatted_ip, conn->port,
 			in_bytes, (int)sizeof(in_buff));
 		result = EINVAL;
 		break;

tracker/tracker_proto.h

@@ -142,6 +142,7 @@ typedef struct
 	char domain_name[FDFS_DOMAIN_NAME_MAX_SIZE];
 	char init_flag;
 	signed char status;
+	char storage_id[FDFS_STORAGE_ID_MAX_SIZE];    //since 6.11
 	char current_tracker_ip[IP_ADDRESS_SIZE];     //current tracker ip address
 	char tracker_count[FDFS_PROTO_PKG_LEN_SIZE];  //all tracker server count
 } TrackerStorageJoinBody;
@@ -149,7 +150,7 @@ typedef struct
 typedef struct
 {
     unsigned char my_status;   //storage server status
-	char src_id[FDFS_STORAGE_ID_MAX_SIZE];  //src storage id
+    char src_id[FDFS_STORAGE_ID_MAX_SIZE];  //src storage id
 } TrackerStorageJoinBodyResp;
 
 typedef struct
@@ -212,6 +213,13 @@ typedef struct
 	char size[4];
 } FDFSTrunkInfoBuff;
 
+
+typedef struct
+{
+    char start_index[4];
+    char allow_empty;
+} FDFSFetchStorageIdsBody;
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -240,13 +248,15 @@ ConnectionInfo *tracker_connect_server_ex(TrackerServerInfo *pServerInfo,
 * connect to the tracker server directly without connection pool
 * params:
 *	pTrackerServer: tracker server
-*   bind_ipaddr: the ip address to bind, NULL or empty for any
+*   bind_addr4: the ipv4 address to bind, NULL or empty for any
+*   bind_addr6: the ipv6 address to bind, NULL or empty for any
 *	err_no: return the error no
 *   log_connect_error: if log error info when connect fail
 * return: ConnectionInfo pointer for success, NULL for fail
 **/
 ConnectionInfo *tracker_connect_server_no_pool_ex(TrackerServerInfo *pServerInfo,
-        const char *bind_addr, int *err_no, const bool log_connect_error);
+        const char *bind_addr4, const char *bind_addr6, int *err_no,
+        const bool log_connect_error);
 
 /**
 * connect to the tracker server directly without connection pool
@@ -258,9 +268,10 @@ ConnectionInfo *tracker_connect_server_no_pool_ex(TrackerServerInfo *pServerInfo
 static inline ConnectionInfo *tracker_connect_server_no_pool(
         TrackerServerInfo *pServerInfo, int *err_no)
 {
-    const char *bind_addr = NULL;
+    const char *bind_addr4 = NULL;
+    const char *bind_addr6 = NULL;
     return tracker_connect_server_no_pool_ex(pServerInfo,
-            bind_addr, err_no, true);
+            bind_addr4, bind_addr6, err_no, true);
 }
 
 #define tracker_close_connection(pTrackerServer) \
@@ -316,15 +327,21 @@ int fdfs_deal_no_body_cmd_ex(const char *ip_addr, const int port, const int cmd)
 		fdfs_split_metadata_ex(meta_buff, FDFS_RECORD_SEPERATOR, \
 		FDFS_FIELD_SEPERATOR, meta_count, err_no)
 
-char *fdfs_pack_metadata(const FDFSMetaData *meta_list, const int meta_count, \
+char *fdfs_pack_metadata(const FDFSMetaData *meta_list, const int meta_count,
 			char *meta_buff, int *buff_bytes);
-FDFSMetaData *fdfs_split_metadata_ex(char *meta_buff, \
-		const char recordSeperator, const char filedSeperator, \
+FDFSMetaData *fdfs_split_metadata_ex(char *meta_buff,
+		const char recordSeperator, const char filedSeperator,
 		int *meta_count, int *err_no);
 
-int fdfs_get_ini_context_from_tracker(TrackerServerGroup *pTrackerGroup, \
-                IniContext *iniContext, bool * volatile continue_flag, \
-                const bool client_bind_addr, const char *bind_addr);
+int fdfs_get_ini_context_from_tracker_ex(TrackerServerGroup *pTrackerGroup,
+                IniContext *iniContext, bool * volatile continue_flag,
+                const bool client_bind_addr, const char *bind_addr4,
+                const char *bind_addr6);
+
+#define fdfs_get_ini_context_from_tracker(pTrackerGroup, \
+        iniContext, continue_flag) \
+        fdfs_get_ini_context_from_tracker_ex(pTrackerGroup, \
+        iniContext, continue_flag, false, NULL, NULL)
 
 int fdfs_get_tracker_status(TrackerServerInfo *pTrackerServer,
 		TrackerRunningStatus *pStatus);

tracker/tracker_relationship.c

@@ -40,6 +40,7 @@ static int fdfs_ping_leader(ConnectionInfo *pTrackerServer)
 	int64_t in_bytes;
 	char in_buff[(FDFS_GROUP_NAME_MAX_LEN + FDFS_STORAGE_ID_MAX_SIZE) * \
 			FDFS_MAX_GROUPS];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char *pInBuff;
 	char *p;
 	char *pEnd;
@@ -49,26 +50,26 @@ static int fdfs_ping_leader(ConnectionInfo *pTrackerServer)
 
 	memset(&header, 0, sizeof(header));
 	header.cmd = TRACKER_PROTO_CMD_TRACKER_PING_LEADER;
-	result = tcpsenddata_nb(pTrackerServer->sock, &header, \
+	result = tcpsenddata_nb(pTrackerServer->sock, &header,
 			sizeof(header), SF_G_NETWORK_TIMEOUT);
 	if(result != 0)
 	{
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
 		logError("file: "__FILE__", line: %d, "
-			"tracker server %s:%u, send data fail, "
-			"errno: %d, error info: %s",
-			__LINE__, pTrackerServer->ip_addr,
+			"tracker server %s:%u, send data fail, errno: %d, "
+			"error info: %s", __LINE__, formatted_ip,
 			pTrackerServer->port, result, STRERROR(result));
 		return result;
 	}
 
 	pInBuff = in_buff;
-	if ((result=fdfs_recv_response(pTrackerServer, &pInBuff, \
+	if ((result=fdfs_recv_response(pTrackerServer, &pInBuff,
 			sizeof(in_buff), &in_bytes)) != 0)
 	{
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
         logError("file: "__FILE__", line: %d, "
                 "fdfs_recv_response from %s:%u fail, result: %d",
-                __LINE__, pTrackerServer->ip_addr,
-		pTrackerServer->port, result);
+                __LINE__, formatted_ip, pTrackerServer->port, result);
 		return result;
 	}
 
@@ -79,9 +80,10 @@ static int fdfs_ping_leader(ConnectionInfo *pTrackerServer)
 	else if (in_bytes % (FDFS_GROUP_NAME_MAX_LEN + \
 			FDFS_STORAGE_ID_MAX_SIZE) != 0)
 	{
+        format_ip_address(pTrackerServer->ip_addr, formatted_ip);
 		logError("file: "__FILE__", line: %d, "
 			"tracker server %s:%u, invalid body length: "
-			"%"PRId64, __LINE__, pTrackerServer->ip_addr,
+			"%"PRId64, __LINE__, formatted_ip,
 			pTrackerServer->port, in_bytes);
 		return EINVAL;
 	}
@@ -198,6 +200,7 @@ static int relationship_get_tracker_leader(TrackerRunningStatus *pTrackerStatus)
 	TrackerServerInfo *pTrackerEnd;
 	TrackerRunningStatus *pStatus;
 	TrackerRunningStatus trackerStatus[FDFS_MAX_TRACKERS];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	int count;
 	int result;
 	int r;
@@ -235,17 +238,20 @@ static int relationship_get_tracker_leader(TrackerRunningStatus *pTrackerStatus)
 	qsort(trackerStatus, count, sizeof(TrackerRunningStatus), \
 		relationship_cmp_tracker_status);
 
-	for (i=0; i<count; i++)
-	{
-		logDebug("file: "__FILE__", line: %d, " \
-			"%s:%u if_leader: %d, running time: %d, " \
-			"restart interval: %d", __LINE__, \
-			trackerStatus[i].pTrackerServer->connections->ip_addr, \
-			trackerStatus[i].pTrackerServer->connections->port, \
-			trackerStatus[i].if_leader, \
-			trackerStatus[i].running_time, \
-			trackerStatus[i].restart_interval);
-	}
+    if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
+        for (i=0; i<count; i++)
+        {
+            format_ip_address(trackerStatus[i].pTrackerServer->
+                    connections->ip_addr, formatted_ip);
+            logDebug("file: "__FILE__", line: %d, "
+                    "%s:%u if_leader: %d, running time: %d, "
+                    "restart interval: %d", __LINE__, formatted_ip,
+                    trackerStatus[i].pTrackerServer->connections->port,
+                    trackerStatus[i].if_leader,
+                    trackerStatus[i].running_time,
+                    trackerStatus[i].restart_interval);
+        }
+    }
 
 	memcpy(pTrackerStatus, trackerStatus + (count - 1), \
 			sizeof(TrackerRunningStatus));
@@ -256,6 +262,7 @@ static int do_notify_leader_changed(TrackerServerInfo *pTrackerServer, \
 		ConnectionInfo *pLeader, const char cmd, bool *bConnectFail)
 {
 	char out_buff[sizeof(TrackerHeader) + FDFS_PROTO_IP_PORT_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	char in_buff[1];
 	ConnectionInfo *conn;
 	TrackerHeader *pHeader;
@@ -276,39 +283,41 @@ static int do_notify_leader_changed(TrackerServerInfo *pTrackerServer, \
 	memset(out_buff, 0, sizeof(out_buff));
 	pHeader = (TrackerHeader *)out_buff;
 	pHeader->cmd = cmd;
-	sprintf(out_buff + sizeof(TrackerHeader), "%s:%u", \
-			pLeader->ip_addr, pLeader->port);
+    format_ip_port(pLeader->ip_addr, pLeader->port,
+            out_buff + sizeof(TrackerHeader));
 	long2buff(FDFS_PROTO_IP_PORT_SIZE, pHeader->pkg_len);
-	if ((result=tcpsenddata_nb(conn->sock, out_buff, \
+	if ((result=tcpsenddata_nb(conn->sock, out_buff,
 			sizeof(out_buff), SF_G_NETWORK_TIMEOUT)) != 0)
 	{
+        format_ip_address(conn->ip_addr, formatted_ip);
 		logError("file: "__FILE__", line: %d, "
-			"send data to tracker server %s:%u fail, "
-			"errno: %d, error info: %s", __LINE__,
-			conn->ip_addr, conn->port, result, STRERROR(result));
+			"send data to tracker server %s:%u fail, errno: %d, "
+			"error info: %s", __LINE__, formatted_ip, conn->port,
+            result, STRERROR(result));
 
 		result = (result == ENOENT ? EACCES : result);
 		break;
 	}
 
 	pInBuff = in_buff;
-	result = fdfs_recv_response(conn, &pInBuff, \
-				0, &in_bytes);
+	result = fdfs_recv_response(conn, &pInBuff, 0, &in_bytes);
 	if (result != 0)
 	{
+        format_ip_address(conn->ip_addr, formatted_ip);
         logError("file: "__FILE__", line: %d, "
                 "fdfs_recv_response from tracker server %s:%u fail, "
-                "result: %d", __LINE__, conn->ip_addr, conn->port, result);
+                "result: %d", __LINE__, formatted_ip, conn->port, result);
 		break;
 	}
 
 	if (in_bytes != 0)
 	{
+        format_ip_address(conn->ip_addr, formatted_ip);
 		logError("file: "__FILE__", line: %d, "
 			"tracker server %s:%u response data "
 			"length: %"PRId64" is invalid, "
 			"expect length: %d.", __LINE__,
-			conn->ip_addr, conn->port, in_bytes, 0);
+			formatted_ip, conn->port, in_bytes, 0);
 		result = EINVAL;
 		break;
 	}
@@ -330,6 +339,8 @@ static int do_notify_leader_changed(TrackerServerInfo *pTrackerServer, \
 void relationship_set_tracker_leader(const int server_index,
         ConnectionInfo *pLeader, const bool leader_self)
 {
+    char formatted_ip[FORMATTED_IP_SIZE];
+
     g_tracker_servers.leader_index = server_index;
     g_next_leader_index = -1;
 
@@ -340,9 +351,10 @@ void relationship_set_tracker_leader(const int server_index,
     }
     else
     {
+        format_ip_address(pLeader->ip_addr, formatted_ip);
         logInfo("file: "__FILE__", line: %d, "
             "the tracker leader is %s:%u", __LINE__,
-            pLeader->ip_addr, pLeader->port);
+            formatted_ip, pLeader->port);
     }
 }
 
@@ -458,6 +470,7 @@ static int relationship_select_leader()
 	int result;
 	TrackerRunningStatus trackerStatus;
     ConnectionInfo *conn;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
 	if (g_tracker_servers.server_count <= 0)
 	{
@@ -482,9 +495,10 @@ static int relationship_select_leader()
 			return result;
 		}
 
+        format_ip_address(conn->ip_addr, formatted_ip);
 		logInfo("file: "__FILE__", line: %d, "
 			"I am the new tracker leader %s:%u",
-			__LINE__, conn->ip_addr, conn->port);
+			__LINE__, formatted_ip, conn->port);
 
 		tracker_mem_find_trunk_servers();
 	}
@@ -509,15 +523,17 @@ static int relationship_select_leader()
 
         if (g_tracker_servers.leader_index >= 0)
         {
+            format_ip_address(conn->ip_addr, formatted_ip);
 			logInfo("file: "__FILE__", line: %d, "
 				"the tracker leader %s:%u", __LINE__,
-				conn->ip_addr, conn->port);
+				formatted_ip, conn->port);
         }
         else
 		{
+            format_ip_address(conn->ip_addr, formatted_ip);
 			logInfo("file: "__FILE__", line: %d, "
 				"waiting for the candidate tracker leader %s:%u notify ...",
-                __LINE__, conn->ip_addr, conn->port);
+                __LINE__, formatted_ip, conn->port);
 			return ENOENT;
 		}
 	}
@@ -560,6 +576,7 @@ static void *relationship_thread_entrance(void* arg)
 
 	int fail_count;
 	int sleep_seconds;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
 #ifdef OS_LINUX
     {
@@ -607,8 +624,9 @@ static void *relationship_thread_entrance(void* arg)
                     {
                         pLeader = g_tracker_servers.servers
                             [leader_index].connections;
+                        format_ip_address(pLeader->ip_addr, formatted_ip);
                         sprintf(leader_str, "leader %s:%u",
-                                pLeader->ip_addr, pLeader->port);
+                                formatted_ip, pLeader->port);
                     }
 
                     ++fail_count;

tracker/tracker_service.c

@@ -66,12 +66,12 @@ static void task_finish_clean_up(struct fast_task_info *pTask)
 }
 
 static int sock_accept_done_callback(struct fast_task_info *task,
-        const in_addr_t client_addr, const bool bInnerPort)
+        const in_addr_64_t client_addr, const bool bInnerPort)
 {
     if (g_allow_ip_count >= 0)
     {
         if (bsearch(&client_addr, g_allow_ip_addrs,
-                    g_allow_ip_count, sizeof(in_addr_t),
+                    g_allow_ip_count, sizeof(in_addr_64_t),
                     cmp_by_ip_addr_t) == NULL)
         {
             logError("file: "__FILE__", line: %d, "
@@ -448,6 +448,7 @@ static int tracker_deal_parameter_req(struct fast_task_info *pTask)
     body_len = sprintf(pTask->send.ptr->data + sizeof(TrackerHeader),
             "use_storage_id=%d\n"
             "id_type_in_filename=%s\n"
+            "trust_storage_server_id=%d\n"
             "storage_ip_changed_auto_adjust=%d\n"
             "storage_sync_file_max_delay=%d\n"
             "store_path=%d\n"
@@ -472,6 +473,7 @@ static int tracker_deal_parameter_req(struct fast_task_info *pTask)
             "store_slave_file_use_link=%d\n",
         g_use_storage_id, g_id_type_in_filename ==
             FDFS_ID_TYPE_SERVER_ID ? "id" : "ip",
+        g_trust_storage_server_id,
         g_storage_ip_changed_auto_adjust,
         g_storage_sync_file_max_delay, g_groups.store_path,
         fdfs_storage_reserved_space_to_string(
@@ -643,6 +645,7 @@ static int tracker_deal_notify_next_leader(struct fast_task_info *pTask)
 	char *pIpAndPort;
 	char *ipAndPort[2];
 	ConnectionInfo leader;
+    char formatted_ip[FORMATTED_IP_SIZE];
 	int server_index;
 	
 	if (pTask->recv.ptr->length - sizeof(TrackerHeader) !=
@@ -661,7 +664,7 @@ static int tracker_deal_notify_next_leader(struct fast_task_info *pTask)
 
 	*(pTask->recv.ptr->data + pTask->recv.ptr->length) = '\0';
 	pIpAndPort = pTask->recv.ptr->data + sizeof(TrackerHeader);
-	if (splitEx(pIpAndPort, ':', ipAndPort, 2) != 2)
+	if (parseAddress(pIpAndPort, ipAndPort) != 2)
 	{
 		logError("file: "__FILE__", line: %d, " \
 			"client ip: %s, invalid ip and port: %s", \
@@ -673,14 +676,15 @@ static int tracker_deal_notify_next_leader(struct fast_task_info *pTask)
 	pTask->send.ptr->length = sizeof(TrackerHeader);
 	strcpy(leader.ip_addr, ipAndPort[0]);
 	leader.port = atoi(ipAndPort[1]);
-	server_index = fdfs_get_tracker_leader_index_ex(&g_tracker_servers, \
+	server_index = fdfs_get_tracker_leader_index_ex(&g_tracker_servers,
 					leader.ip_addr, leader.port);
 	if (server_index < 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"client ip: %s, leader %s:%u not exist", \
-			__LINE__, pTask->client_ip, \
-			leader.ip_addr, leader.port);
+        format_ip_address(leader.ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"client ip: %s, leader %s:%u not exist",
+			__LINE__, pTask->client_ip,
+			formatted_ip, leader.port);
 		return ENOENT;
 	}
 
@@ -691,11 +695,11 @@ static int tracker_deal_notify_next_leader(struct fast_task_info *pTask)
 		g_tracker_servers.leader_index = -1;
 		g_tracker_leader_chg_count++;
 
-		logError("file: "__FILE__", line: %d, " \
-			"client ip: %s, two leaders occur, " \
-			"new leader is %s:%u", \
-			__LINE__, pTask->client_ip, \
-			leader.ip_addr, leader.port);
+        format_ip_address(leader.ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"client ip: %s, two leaders occur, new leader "
+			"is %s:%u", __LINE__, pTask->client_ip,
+            formatted_ip, leader.port);
 		return EINVAL;
 	}
 
@@ -708,6 +712,7 @@ static int tracker_deal_commit_next_leader(struct fast_task_info *pTask)
 	char *pIpAndPort;
 	char *ipAndPort[2];
 	ConnectionInfo leader;
+    char formatted_ip[FORMATTED_IP_SIZE];
 	int server_index;
     bool leader_self;
 	
@@ -727,7 +732,7 @@ static int tracker_deal_commit_next_leader(struct fast_task_info *pTask)
 
 	*(pTask->recv.ptr->data + pTask->recv.ptr->length) = '\0';
 	pIpAndPort = pTask->recv.ptr->data + sizeof(TrackerHeader);
-	if (splitEx(pIpAndPort, ':', ipAndPort, 2) != 2)
+	if (parseAddress(pIpAndPort, ipAndPort) != 2)
 	{
 		logError("file: "__FILE__", line: %d, " \
 			"client ip: %s, invalid ip and port: %s", \
@@ -743,18 +748,20 @@ static int tracker_deal_commit_next_leader(struct fast_task_info *pTask)
 					leader.ip_addr, leader.port);
 	if (server_index < 0)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"client ip: %s, leader %s:%u not exist", \
-			__LINE__, pTask->client_ip, \
-			leader.ip_addr, leader.port);
+        format_ip_address(leader.ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"client ip: %s, leader %s:%u not exist",
+			__LINE__, pTask->client_ip,
+			formatted_ip, leader.port);
 		return ENOENT;
 	}
 	if (server_index != g_next_leader_index)
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"client ip: %s, can't commit leader %s:%u", \
-			__LINE__, pTask->client_ip, \
-			leader.ip_addr, leader.port);
+        format_ip_address(leader.ip_addr, formatted_ip);
+		logError("file: "__FILE__", line: %d, "
+			"client ip: %s, can't commit leader %s:%u",
+			__LINE__, pTask->client_ip,
+			formatted_ip, leader.port);
 		return EINVAL;
 	}
 
@@ -845,7 +852,7 @@ static int tracker_deal_get_storage_id(struct fast_task_info *pTask)
 	char group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
 	char ip_addr[IP_ADDRESS_SIZE];
 	FDFSStorageIdInfo *pFDFSStorageIdInfo;
-	char *storage_id;
+    FDFSStorageId storage_id;
 	int nPkgLen;
 	int id_len;
 
@@ -897,17 +904,26 @@ static int tracker_deal_get_storage_id(struct fast_task_info *pTask)
 			return ENOENT;
 		}
 
-		storage_id = pFDFSStorageIdInfo->id;
+		storage_id.ptr = pFDFSStorageIdInfo->id;
 	}
 	else
-	{
-		storage_id = ip_addr;
-	}
+    {
+        // 当IP地址为IPv6时，其storage_id值为IP地址的short code
+        if (is_ipv6_addr(ip_addr))
+        {
+            storage_id.ptr = fdfs_ip_to_shortcode(ip_addr,
+                    storage_id.holder);
+        }
+        else
+        {
+            storage_id.ptr = ip_addr;
+        }
+    }
 
-	id_len = strlen(storage_id);
+	id_len = strlen(storage_id.ptr);
 	pTask->send.ptr->length = sizeof(TrackerHeader) + id_len; 
-	memcpy(pTask->send.ptr->data + sizeof(TrackerHeader), storage_id, id_len);
-
+	memcpy(pTask->send.ptr->data + sizeof(TrackerHeader),
+            storage_id.ptr, id_len);
 	return 0;
 }
 
@@ -973,6 +989,7 @@ static int tracker_deal_get_my_ip(struct fast_task_info *pTask)
 static int tracker_deal_get_storage_group_name(struct fast_task_info *pTask)
 {
 	char ip_addr[IP_ADDRESS_SIZE];
+    char formatted_ip[FORMATTED_IP_SIZE];
 	FDFSStorageIdInfo *pFDFSStorageIdInfo;
     char *pPort;
     int port;
@@ -1027,9 +1044,10 @@ static int tracker_deal_get_storage_group_name(struct fast_task_info *pTask)
     pFDFSStorageIdInfo = fdfs_get_storage_id_by_ip_port(ip_addr, port);
     if (pFDFSStorageIdInfo == NULL)
     {
+        format_ip_address(ip_addr, formatted_ip);
         logError("file: "__FILE__", line: %d, "
                 "client ip: %s, can't get group name for storage %s:%u",
-                __LINE__, pTask->client_ip, ip_addr, port);
+                __LINE__, pTask->client_ip, formatted_ip, port);
         pTask->send.ptr->length = sizeof(TrackerHeader);
         return ENOENT;
     }
@@ -1043,6 +1061,7 @@ static int tracker_deal_get_storage_group_name(struct fast_task_info *pTask)
 
 static int tracker_deal_fetch_storage_ids(struct fast_task_info *pTask)
 {
+    FDFSFetchStorageIdsBody *req_body;
 	FDFSStorageIdInfo *pIdsStart;
 	FDFSStorageIdInfo *pIdsEnd;
 	FDFSStorageIdInfo *pIdInfo;
@@ -1052,37 +1071,45 @@ static int tracker_deal_fetch_storage_ids(struct fast_task_info *pTask)
 	int start_index;
     char ip_str[256];
 
-	if (!g_use_storage_id)
+	nPkgLen = pTask->recv.ptr->length - sizeof(TrackerHeader);
+	if (nPkgLen != sizeof(*req_body))
 	{
-		logError("file: "__FILE__", line: %d, " \
-			"client ip addr: %s, operation not supported", \
+		logError("file: "__FILE__", line: %d, "
+			"cmd=%d, client ip addr: %s, package size %d "
+            "is not correct, expect %d bytes", __LINE__,
+			TRACKER_PROTO_CMD_STORAGE_FETCH_STORAGE_IDS,
+			pTask->client_ip, nPkgLen, (int)sizeof(*req_body));
+		pTask->send.ptr->length = sizeof(TrackerHeader);
+		return EINVAL;
+	}
+
+    req_body = (FDFSFetchStorageIdsBody *)(pTask->recv.ptr->data +
+            sizeof(TrackerHeader));
+    if (!g_use_storage_id)
+	{
+        if (req_body->allow_empty)
+        {
+            pTask->send.ptr->length = sizeof(TrackerHeader) + 8;
+            memset(pTask->send.ptr->data + sizeof(TrackerHeader), 0, 8);
+            return 0;
+        }
+
+		logError("file: "__FILE__", line: %d, "
+			"client ip addr: %s, operation not supported",
 			__LINE__, pTask->client_ip);
 		pTask->send.ptr->length = sizeof(TrackerHeader);
 		return EOPNOTSUPP;
 	}
 
-	nPkgLen = pTask->recv.ptr->length - sizeof(TrackerHeader);
-	if (nPkgLen != sizeof(int))
-	{
-		logError("file: "__FILE__", line: %d, " \
-			"cmd=%d, client ip addr: %s, " \
-			"package size %d is not correct, " \
-			"expect %d bytes", __LINE__, \
-			TRACKER_PROTO_CMD_STORAGE_FETCH_STORAGE_IDS, \
-			pTask->client_ip, nPkgLen, (int)sizeof(int));
-		pTask->send.ptr->length = sizeof(TrackerHeader);
-		return EINVAL;
-	}
-
-	start_index = buff2int(pTask->recv.ptr->data + sizeof(TrackerHeader));
+	start_index = buff2int(req_body->start_index);
 	if (start_index < 0 || start_index >= g_storage_ids_by_id.count)
-	{
-		logError("file: "__FILE__", line: %d, " \
-			"client ip addr: %s, invalid offset: %d", \
-			__LINE__, pTask->client_ip, start_index);
-		pTask->send.ptr->length = sizeof(TrackerHeader);
-		return EINVAL;
-	}
+    {
+        logError("file: "__FILE__", line: %d, "
+                "client ip addr: %s, invalid offset: %d",
+                __LINE__, pTask->client_ip, start_index);
+        pTask->send.ptr->length = sizeof(TrackerHeader);
+        return EINVAL;
+    }
 
 	p = pTask->send.ptr->data + sizeof(TrackerHeader);
 	int2buff(g_storage_ids_by_id.count, p);
@@ -1111,8 +1138,16 @@ static int tracker_deal_fetch_storage_ids(struct fast_task_info *pTask)
 
         fdfs_multi_ips_to_string(&pIdInfo->ip_addrs,
                 ip_str, sizeof(ip_str));
-		p += sprintf(p, "%s %s %s%s\n", pIdInfo->id,
-			pIdInfo->group_name, ip_str, szPortPart);
+		if (strchr(ip_str, ':') != NULL)
+        {
+            p += sprintf(p, "%s %s [%s]%s\n", pIdInfo->id,
+                    pIdInfo->group_name, ip_str, szPortPart);
+        }
+        else
+        {
+            p += sprintf(p, "%s %s %s%s\n", pIdInfo->id,
+                    pIdInfo->group_name, ip_str, szPortPart);
+        }
 	}
 
 	int2buff((int)(pIdInfo - pIdsStart), (char *)pCurrentCount);
@@ -1227,7 +1262,7 @@ static int tracker_deal_storage_join(struct fast_task_info *pTask)
 
 	pClientInfo = (TrackerClientInfo *)pTask->arg;
 
-	if (pTask->recv.ptr->length - sizeof(TrackerHeader) < \
+	if (pTask->recv.ptr->length - sizeof(TrackerHeader) <
 			sizeof(TrackerStorageJoinBody))
 	{
 		logError("file: "__FILE__", line: %d, " \
@@ -1360,6 +1395,7 @@ static int tracker_deal_storage_join(struct fast_task_info *pTask)
 	strcpy(joinBody.domain_name, pBody->domain_name);
 	joinBody.init_flag = pBody->init_flag;
 	joinBody.status = pBody->status;
+	memcpy(joinBody.storage_id, pBody->storage_id, FDFS_STORAGE_ID_MAX_SIZE);
 
     pBody->current_tracker_ip[IP_ADDRESS_SIZE - 1] = '\0';
 
@@ -1991,7 +2027,7 @@ static int tracker_deal_storage_report_ip_changed(struct fast_task_info *pTask)
 	}
 
 	pTask->send.ptr->length = sizeof(TrackerHeader);
-	return tracker_mem_storage_ip_changed(pGroup, \
+	return tracker_mem_storage_ip_changed(pGroup,
 			pOldIpAddr, pNewIpAddr);
 }
 
@@ -2534,9 +2570,9 @@ static int tracker_deal_service_query_storage( \
 		if (pStoreGroup == NULL)
 		{
 			FDFSGroupInfo **ppGroupEnd;
-			ppGroupEnd = g_groups.sorted_groups + \
+			ppGroupEnd = g_groups.sorted_groups +
 				     g_groups.count;
-			for (ppGroup=ppFoundGroup+1; \
+			for (ppGroup=ppFoundGroup+1;
 					ppGroup<ppGroupEnd; ppGroup++)
 			{
 				if ((*ppGroup)->active_count == 0)
@@ -2548,7 +2584,7 @@ static int tracker_deal_service_query_storage( \
 				if (tracker_check_reserved_space(*ppGroup))
 				{
 					pStoreGroup = *ppGroup;
-					g_groups.current_write_group = \
+					g_groups.current_write_group =
 					       ppGroup-g_groups.sorted_groups;
 					break;
 				}
@@ -2556,7 +2592,7 @@ static int tracker_deal_service_query_storage( \
 
 			if (pStoreGroup == NULL)
 			{
-				for (ppGroup=g_groups.sorted_groups; \
+				for (ppGroup=g_groups.sorted_groups;
 						ppGroup<ppFoundGroup; ppGroup++)
 				{
 					if ((*ppGroup)->active_count == 0)
@@ -2568,7 +2604,7 @@ static int tracker_deal_service_query_storage( \
 					if (tracker_check_reserved_space(*ppGroup))
 					{
 						pStoreGroup = *ppGroup;
-						g_groups.current_write_group = \
+						g_groups.current_write_group =
 						 ppGroup-g_groups.sorted_groups;
 						break;
 					}
@@ -2589,7 +2625,7 @@ static int tracker_deal_service_query_storage( \
 					return ENOSPC;
 				}
 
-				for (ppGroup=g_groups.sorted_groups; \
+				for (ppGroup=g_groups.sorted_groups;
 						ppGroup<ppGroupEnd; ppGroup++)
 				{
 					if ((*ppGroup)->active_count == 0)
@@ -2599,7 +2635,7 @@ static int tracker_deal_service_query_storage( \
 					if (tracker_check_reserved_space_trunk(*ppGroup))
 					{
 						pStoreGroup = *ppGroup;
-						g_groups.current_write_group = \
+						g_groups.current_write_group =
 						 ppGroup-g_groups.sorted_groups;
 						break;
 					}
@@ -2624,7 +2660,7 @@ static int tracker_deal_service_query_storage( \
 	}
 	else if (g_groups.store_lookup == FDFS_STORE_LOOKUP_SPEC_GROUP)
 	{
-		if (g_groups.pStoreGroup == NULL || \
+		if (g_groups.pStoreGroup == NULL ||
 				g_groups.pStoreGroup->active_count == 0)
 		{
 			pTask->send.ptr->length = sizeof(TrackerHeader);
@@ -2633,8 +2669,8 @@ static int tracker_deal_service_query_storage( \
 
 		if (!tracker_check_reserved_space(g_groups.pStoreGroup))
 		{
-			if (!(g_if_use_trunk_file && \
-				tracker_check_reserved_space_trunk( \
+			if (!(g_if_use_trunk_file &&
+				tracker_check_reserved_space_trunk(
 						g_groups.pStoreGroup)))
 			{
 				pTask->send.ptr->length = sizeof(TrackerHeader);
@@ -2738,7 +2774,7 @@ static int tracker_deal_service_query_storage( \
 	if (g_groups.store_path == FDFS_STORE_PATH_ROUND_ROBIN)
 	{
 		pStorageServer->current_write_path++;
-		if (pStorageServer->current_write_path >= \
+		if (pStorageServer->current_write_path >=
 				pStoreGroup->store_path_count)
 		{
 			pStorageServer->current_write_path = 0;
@@ -2879,9 +2915,9 @@ static int tracker_deal_server_list_all_groups(struct fast_task_info *pTask)
 
     expect_size = sizeof(TrackerHeader) + g_groups.count *
         sizeof(TrackerGroupStat);
-    if (expect_size > g_sf_global_vars.min_buff_size)
+    if (expect_size > g_sf_global_vars.net_buffer_cfg.min_buff_size)
     {
-        if (expect_size <= g_sf_global_vars.max_buff_size)
+        if (expect_size <= g_sf_global_vars.net_buffer_cfg.max_buff_size)
         {
             if ((result=free_queue_set_send_buffer_size(pTask, expect_size)) != 0)
             {
@@ -2897,7 +2933,7 @@ static int tracker_deal_server_list_all_groups(struct fast_task_info *pTask)
                     "you should increase max_buff_size in tracker.conf",
                     __LINE__, TRACKER_PROTO_CMD_SERVER_LIST_ALL_GROUPS,
                     pTask->client_ip, expect_size,
-                    g_sf_global_vars.max_buff_size);
+                    g_sf_global_vars.net_buffer_cfg.max_buff_size);
             pTask->send.ptr->length = sizeof(TrackerHeader);
             return ENOSPC;
         }

tracker/tracker_types.h

@@ -48,7 +48,7 @@
 #define FDFS_TRUNK_LOGIC_FILENAME_LENGTH  (FDFS_TRUNK_FILENAME_LENGTH + \
 		(FDFS_LOGIC_FILE_PATH_LEN - FDFS_TRUE_FILE_PATH_LEN))
 
-#define FDFS_VERSION_SIZE		6
+#define FDFS_VERSION_SIZE		8
 
 //status order is important!
 #define FDFS_STORAGE_STATUS_INIT	  0
@@ -427,6 +427,7 @@ typedef struct
     char version[FDFS_VERSION_SIZE];   //storage version
     char group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
     char domain_name[FDFS_DOMAIN_NAME_MAX_SIZE];
+    char storage_id[FDFS_STORAGE_ID_MAX_SIZE];
     char init_flag;
     signed char status;
     int tracker_count;
@@ -471,5 +472,10 @@ typedef struct {
 	bool if_leader;       //if leader
 } TrackerRunningStatus;
 
+typedef struct {
+    char *ptr;
+    char holder[FDFS_STORAGE_ID_MAX_SIZE];
+} FDFSStorageId;
+
 #endif