query file info support two combined flags

Added: 增加IPv6支持

.gitignore

@@ -15,3 +15,4 @@ target
 *.conf
 *.PNG
 *.class
+*.swp

HISTORY

@@ -1,3 +1,38 @@
+
+Version 1.37  2025-11-06
+  * query file info support two combined flags:
+        ProtoCommon.FDFS_QUERY_FINFO_FLAGS_NOT_CALC_CRC32
+        ProtoCommon.FDFS_QUERY_FINFO_FLAGS_KEEP_SILENCE
+    you must upgrade your FastDFS server V6.15.1 and higher version
+
+Version 1.36  2025-10-26
+  * monitor protocol compatible with IPv4/IPv6 address automatically
+  * FastDFS server version requirements:
+    # group and storage statistics / monitor APIs: FastDFS server >= V6.13.1
+    # other APIs: FastDFS server >= V6.06
+
+Version 1.35  2025-09-04
+  * group and storage statistics / monitor API output reserved
+    and available space
+  * you must upgrade your FastDFS server V6.13.1 and higher version
+
+Version 1.34  2025-08-28
+  * adapt to FastDFS server V6.13 for read-write separation
+    you must upgrade your FastDFS server V6.13 and higher version
+
+Version 1.33  2025-07-21
+  * protocol automatically compatible with IPv4/IPv6 address
+    this version for FastDFS server V6.06 and higher version
+
+Version 1.32  2024-02-12
+  * change FDFS_VERSION_SIZE from 6 to 8
+    you must upgrade your FastDFS server to V6.12 or higher version
+
+Version 1.31  2023-12-13
+  * adapt to FastDFS server V6.11 for IPv6
+    you must upgrade your FastDFS server to V6.11 or higher version
+  * connect to storage server failover with multi IPs
+
 Version 1.30  2023-01-29
   * support tracker server fail over
     If the tracker server is not specified, when the tracker server fails to

README.md

@@ -26,7 +26,7 @@ mvn install:install-file -DgroupId=org.csource -DartifactId=fastdfs-client-java
 <dependency>
     <groupId>org.csource</groupId>
     <artifactId>fastdfs-client-java</artifactId>
-    <version>1.29-SNAPSHOT</version>
+    <version>1.31-SNAPSHOT</version>
 </dependency>
 ```
 

fdfs_client.conf

@@ -5,10 +5,23 @@ http.tracker_http_port = 8080
 http.anti_steal_token = no
 http.secret_key = FastDFS1234567890
 
+#tracker_server
+#   IPv4:
+#   for example: 192.168.2.100,122.244.141.46:22122
+#
+#   IPv6:
+#    for example: [2409:8a20:42d:2f40:587a:4c47:72c0:ad8e]:22122
+#
 tracker_server = 10.0.11.247:22122
 tracker_server = 10.0.11.248:22122
 tracker_server = 10.0.11.249:22122
 
+# 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
+connect_first_by = tracker
+
 connection_pool.enabled = true
 connection_pool.max_count_per_entry = 500
 connection_pool.max_idle_time = 3600

pom.xml

@@ -4,7 +4,7 @@
 
   <groupId>org.csource</groupId>
   <artifactId>fastdfs-client-java</artifactId>
-  <version>1.30-SNAPSHOT</version>
+  <version>1.37-SNAPSHOT</version>
   <name>fastdfs-client-java</name>
   <description>fastdfs client for java</description>
   <packaging>jar</packaging>

src/main/java/org/csource/fastdfs/ClientGlobal.java

@@ -13,6 +13,7 @@ import org.csource.common.MyException;
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.Socket;
 import java.util.ArrayList;
@@ -23,7 +24,7 @@ import java.util.Properties;
  * Global variables
  *
  * @author Happy Fish / YuQing
- * @version Version 1.11
+ * @version Version 1.33
  */
 public class ClientGlobal {
 
@@ -41,13 +42,15 @@ public class ClientGlobal {
   public static final String PROP_KEY_HTTP_SECRET_KEY = "fastdfs.http_secret_key";
   public static final String PROP_KEY_HTTP_TRACKER_HTTP_PORT = "fastdfs.http_tracker_http_port";
   public static final String PROP_KEY_TRACKER_SERVERS = "fastdfs.tracker_servers";
-
+  public static final String PROP_KEY_CONNECT_FIRST_BY = "fastdfs.connect_first_by";
 
   public static final String PROP_KEY_CONNECTION_POOL_ENABLED = "fastdfs.connection_pool.enabled";
   public static final String PROP_KEY_CONNECTION_POOL_MAX_COUNT_PER_ENTRY = "fastdfs.connection_pool.max_count_per_entry";
   public static final String PROP_KEY_CONNECTION_POOL_MAX_IDLE_TIME = "fastdfs.connection_pool.max_idle_time";
   public static final String PROP_KEY_CONNECTION_POOL_MAX_WAIT_TIME_IN_MS = "fastdfs.connection_pool.max_wait_time_in_ms";
 
+  public static final String PROP_KEY_HAVE_ALLOW_EMPTY_FIELD = "fastdfs.fetch_storage_ids.have_allow_empty_field";
+
   public static final int DEFAULT_CONNECT_TIMEOUT = 5; //second
   public static final int DEFAULT_NETWORK_TIMEOUT = 30; //second
   public static final String DEFAULT_CHARSET = "UTF-8";
@@ -55,6 +58,9 @@ public class ClientGlobal {
   public static final String DEFAULT_HTTP_SECRET_KEY = "FastDFS1234567890";
   public static final int DEFAULT_HTTP_TRACKER_HTTP_PORT = 80;
 
+  public static final int CONNECT_FIRST_BY_TRACKER = 0;
+  public static final int CONNECT_FIRST_BY_LAST_CONNECTED = 1;
+
   public static final boolean DEFAULT_CONNECTION_POOL_ENABLED = true;
   public static final int DEFAULT_CONNECTION_POOL_MAX_COUNT_PER_ENTRY = 100;
   public static final int DEFAULT_CONNECTION_POOL_MAX_IDLE_TIME = 3600 ;//second
@@ -66,17 +72,95 @@ public class ClientGlobal {
   public static boolean g_anti_steal_token = DEFAULT_HTTP_ANTI_STEAL_TOKEN; //if anti-steal token
   public static String g_secret_key = DEFAULT_HTTP_SECRET_KEY; //generage token secret key
   public static int g_tracker_http_port = DEFAULT_HTTP_TRACKER_HTTP_PORT;
+  public static int g_connect_first_by = CONNECT_FIRST_BY_TRACKER;
+  public static boolean g_multi_storage_ips = false;
+  public static StorageAddressMap g_storages_address_map;
 
   public static boolean g_connection_pool_enabled = DEFAULT_CONNECTION_POOL_ENABLED;
   public static int g_connection_pool_max_count_per_entry = DEFAULT_CONNECTION_POOL_MAX_COUNT_PER_ENTRY;
   public static int g_connection_pool_max_idle_time = DEFAULT_CONNECTION_POOL_MAX_IDLE_TIME * 1000; //millisecond
   public static int g_connection_pool_max_wait_time_in_ms = DEFAULT_CONNECTION_POOL_MAX_WAIT_TIME_IN_MS; //millisecond
 
+  public static final boolean DEFAULT_HAVE_ALLOW_EMPTY_FIELD = true;
+  public static boolean g_have_allow_empty_field = DEFAULT_HAVE_ALLOW_EMPTY_FIELD;
+
   public static TrackerGroup g_tracker_group;
 
   private ClientGlobal() {
   }
 
+  private static void loadStorageServersFromTracker() throws IOException, MyException {
+      TrackerClient tracker = new TrackerClient();
+      StringBuilder builder = tracker.fetchStorageIds(g_have_allow_empty_field);
+      if (builder == null && g_have_allow_empty_field) {
+          builder = tracker.fetchStorageIds(false);
+      }
+
+      if (builder == null || builder.length() == 0) {
+          return;
+      }
+
+      boolean without_port = true;
+      int count = 0;
+      String[] lines = builder.toString().split("\n");
+      String[] ipAddresses = new String[lines.length];
+      for (String line : lines) {
+          String[] cols = line.split(" ");
+          if (cols.length != 3) {
+              throw new MyException("invalid line: " + line);
+          }
+
+          String ipAddrs = cols[2];
+          if (ipAddrs.indexOf(',') > 0) {
+              ipAddresses[count++] = ipAddrs;
+          }
+      }
+
+      if (count == 0) {
+          return;
+      }
+
+      int startIndex;
+      if (ipAddresses[0].charAt(0) == '[') {  //IPv6
+          if ((startIndex=ipAddresses[0].indexOf(']')) < 0) {
+              throw new MyException("invalid IPv6 address: " + ipAddresses[0]);
+          }
+      } else {
+          startIndex = 0;
+      }
+      if (ipAddresses[0].indexOf(':', startIndex) > 0) {
+          without_port = false;
+      }
+
+      g_multi_storage_ips = true;
+      g_storages_address_map = new StorageAddressMap(without_port);
+      if (without_port) {
+          for (String ipAddr: ipAddresses) {
+              if (ipAddr.charAt(0) == '[') {  //IPv6
+                  ipAddr = ipAddr.substring(1, ipAddr.length() - 1);
+              }
+              String[] cols = ipAddr.split(",");
+              g_storages_address_map.puts(cols[0], cols[1]);
+          }
+      } else {
+          for (String ipPort: ipAddresses) {
+              int colonIndex = ipPort.lastIndexOf(':');
+              if (colonIndex < 0) {
+                  throw new MyException("invalid ip and port: " + ipPort);
+              }
+
+              String ipAddr = ipPort.substring(0, colonIndex);
+              int port = Integer.parseInt(ipPort.substring(colonIndex + 1));
+
+              if (ipAddr.charAt(0) == '[') {  //IPv6
+                  ipAddr = ipAddr.substring(1, ipAddr.length() - 1);
+              }
+              String[] cols = ipAddr.split(",");
+              g_storages_address_map.puts(cols[0], cols[1], port);
+          }
+      }
+  }
+
   /**
    * load global variables
    *
@@ -113,15 +197,27 @@ public class ClientGlobal {
 
     InetSocketAddress[] tracker_servers = new InetSocketAddress[szTrackerServers.length];
     for (int i = 0; i < szTrackerServers.length; i++) {
-      parts = szTrackerServers[i].split("\\:", 2);
+      if (szTrackerServers[i].contains("[")) {
+        parts = new String[2];
+        parts[0] = szTrackerServers[i].substring(1, szTrackerServers[i].indexOf("]"));
+        parts[1] = szTrackerServers[i].substring(szTrackerServers[i].lastIndexOf(":") + 1);
+      } else {
+        parts = szTrackerServers[i].split("\\:", 2);
+      }
+
       if (parts.length != 2) {
         throw new MyException("the value of item \"tracker_server\" is invalid, the correct format is host:port");
       }
 
-      tracker_servers[i] = new InetSocketAddress(parts[0].trim(), Integer.parseInt(parts[1].trim()));
+      tracker_servers[i] = new InetSocketAddress(InetAddress.getByName(parts[0].trim()), Integer.parseInt(parts[1].trim()));
     }
     g_tracker_group = new TrackerGroup(tracker_servers);
 
+    String connect_first_by = iniReader.getStrValue("connect_first_by");
+    if (connect_first_by != null && connect_first_by.equalsIgnoreCase("last-connected")) {
+        g_connect_first_by = CONNECT_FIRST_BY_LAST_CONNECTED;
+    }
+
     g_tracker_http_port = iniReader.getIntValue("http.tracker_http_port", 80);
     g_anti_steal_token = iniReader.getBoolValue("http.anti_steal_token", false);
     if (g_anti_steal_token) {
@@ -138,6 +234,9 @@ public class ClientGlobal {
     if (g_connection_pool_max_wait_time_in_ms < 0) {
       g_connection_pool_max_wait_time_in_ms = DEFAULT_CONNECTION_POOL_MAX_WAIT_TIME_IN_MS;
     }
+
+    g_have_allow_empty_field = iniReader.getBoolValue("fetch_storage_ids.have_allow_empty_field", DEFAULT_HAVE_ALLOW_EMPTY_FIELD);
+    loadStorageServersFromTracker();
   }
 
   /**
@@ -175,6 +274,8 @@ public class ClientGlobal {
     String httpAntiStealTokenConf = props.getProperty(PROP_KEY_HTTP_ANTI_STEAL_TOKEN);
     String httpSecretKeyConf = props.getProperty(PROP_KEY_HTTP_SECRET_KEY);
     String httpTrackerHttpPortConf = props.getProperty(PROP_KEY_HTTP_TRACKER_HTTP_PORT);
+
+    String connectFirstBy = props.getProperty(PROP_KEY_CONNECT_FIRST_BY);
     String poolEnabled = props.getProperty(PROP_KEY_CONNECTION_POOL_ENABLED);
     String poolMaxCountPerEntry = props.getProperty(PROP_KEY_CONNECTION_POOL_MAX_COUNT_PER_ENTRY);
     String poolMaxIdleTime  = props.getProperty(PROP_KEY_CONNECTION_POOL_MAX_IDLE_TIME);
@@ -197,6 +298,10 @@ public class ClientGlobal {
     if (httpTrackerHttpPortConf != null && httpTrackerHttpPortConf.trim().length() != 0) {
       g_tracker_http_port = Integer.parseInt(httpTrackerHttpPortConf);
     }
+
+    if (connectFirstBy != null && connectFirstBy.equalsIgnoreCase("last-connected")) {
+        g_connect_first_by = CONNECT_FIRST_BY_LAST_CONNECTED;
+    }
     if (poolEnabled != null && poolEnabled.trim().length() != 0) {
       g_connection_pool_enabled = Boolean.parseBoolean(poolEnabled);
     }
@@ -209,6 +314,13 @@ public class ClientGlobal {
     if (poolMaxWaitTimeInMS != null && poolMaxWaitTimeInMS.trim().length() != 0) {
       g_connection_pool_max_wait_time_in_ms = Integer.parseInt(poolMaxWaitTimeInMS);
     }
+
+    String haveAllowEmptyField = props.getProperty(PROP_KEY_HAVE_ALLOW_EMPTY_FIELD);
+    if (haveAllowEmptyField != null && haveAllowEmptyField.trim().length() != 0) {
+      g_have_allow_empty_field = Boolean.parseBoolean(haveAllowEmptyField);
+    }
+
+    loadStorageServersFromTracker();
   }
 
   /**
@@ -224,10 +336,16 @@ public class ClientGlobal {
     String spr2 = ":";
     String[] arr1 = trackerServers.trim().split(spr1);
     for (String addrStr : arr1) {
-      String[] arr2 = addrStr.trim().split(spr2);
-      String host = arr2[0].trim();
-      int port = Integer.parseInt(arr2[1].trim());
-      list.add(new InetSocketAddress(host, port));
+      if(addrStr.contains("[")) {
+        String host = addrStr.substring(1, addrStr.indexOf("]"));
+        int port = Integer.parseInt(addrStr.substring(addrStr.lastIndexOf(":") + 1));
+        list.add(new InetSocketAddress(InetAddress.getByName(host), port));
+      } else {
+        String[] arr2 = addrStr.trim().split(spr2);
+        String host = arr2[0].trim();
+        int port = Integer.parseInt(arr2[1].trim());
+        list.add(new InetSocketAddress(InetAddress.getByName(host), port));
+      }
     }
     InetSocketAddress[] trackerAddresses = list.toArray(new InetSocketAddress[list.size()]);
     initByTrackers(trackerAddresses);
@@ -247,7 +365,7 @@ public class ClientGlobal {
   public static Socket getSocket(String ip_addr, int port) throws IOException {
     Socket sock = new Socket();
     sock.setSoTimeout(ClientGlobal.g_network_timeout);
-    sock.connect(new InetSocketAddress(ip_addr, port), ClientGlobal.g_connect_timeout);
+    sock.connect(new InetSocketAddress(InetAddress.getByName(ip_addr), port), ClientGlobal.g_connect_timeout);
     return sock;
   }
 
@@ -346,10 +464,13 @@ public class ClientGlobal {
       + "\n  g_anti_steal_token = " + g_anti_steal_token
       + "\n  g_secret_key = " + g_secret_key
       + "\n  g_tracker_http_port = " + g_tracker_http_port
+      + "\n  g_multi_storage_ips = " + g_multi_storage_ips
+      + "\n  g_connect_first_by = " + (g_connect_first_by == CONNECT_FIRST_BY_TRACKER ? "tracker" : "last-connected")
       + "\n  g_connection_pool_enabled = " + g_connection_pool_enabled
       + "\n  g_connection_pool_max_count_per_entry = " + g_connection_pool_max_count_per_entry
       + "\n  g_connection_pool_max_idle_time(ms) = " + g_connection_pool_max_idle_time
       + "\n  g_connection_pool_max_wait_time_in_ms(ms) = " + g_connection_pool_max_wait_time_in_ms
+      + "\n  g_have_allow_empty_field = " + g_have_allow_empty_field
       + "\n  trackerServers = " + trackerServers
       + "\n}";
   }

src/main/java/org/csource/fastdfs/ProtoCommon.java

@@ -26,6 +26,7 @@ import java.util.Arrays;
  */
 public class ProtoCommon {
   public static final byte FDFS_PROTO_CMD_QUIT = 82;
+  public static final byte TRACKER_PROTO_CMD_FETCH_STORAGE_IDS = 69;
   public static final byte TRACKER_PROTO_CMD_SERVER_LIST_GROUP = 91;
   public static final byte TRACKER_PROTO_CMD_SERVER_LIST_STORAGE = 92;
   public static final byte TRACKER_PROTO_CMD_SERVER_DELETE_STORAGE = 93;
@@ -72,16 +73,20 @@ public class ProtoCommon {
   public static final int FDFS_PROTO_PKG_LEN_SIZE = 8;
   public static final int FDFS_PROTO_CMD_SIZE = 1;
   public static final int FDFS_GROUP_NAME_MAX_LEN = 16;
-  public static final int FDFS_IPADDR_SIZE = 16;
-  public static final int FDFS_DOMAIN_NAME_MAX_SIZE = 128;
-  public static final int FDFS_VERSION_SIZE = 6;
+  public static final int FDFS_IPV4_SIZE = 16;
+  public static final int FDFS_IPV6_SIZE = 46;
+  public static final int FDFS_VERSION_SIZE = 8;
   public static final int FDFS_STORAGE_ID_MAX_SIZE = 16;
   public static final String FDFS_RECORD_SEPERATOR = "\u0001";
   public static final String FDFS_FIELD_SEPERATOR = "\u0002";
-  public static final int TRACKER_QUERY_STORAGE_FETCH_BODY_LEN = FDFS_GROUP_NAME_MAX_LEN
-    + FDFS_IPADDR_SIZE - 1 + FDFS_PROTO_PKG_LEN_SIZE;
-  public static final int TRACKER_QUERY_STORAGE_STORE_BODY_LEN = FDFS_GROUP_NAME_MAX_LEN
-    + FDFS_IPADDR_SIZE + FDFS_PROTO_PKG_LEN_SIZE;
+  public static final int TRACKER_QUERY_STORAGE_FETCH_IPV4_BODY_LEN = FDFS_GROUP_NAME_MAX_LEN
+    + FDFS_IPV4_SIZE - 1 + FDFS_PROTO_PKG_LEN_SIZE;
+  public static final int TRACKER_QUERY_STORAGE_FETCH_IPV6_BODY_LEN = FDFS_GROUP_NAME_MAX_LEN
+    + FDFS_IPV6_SIZE - 1 + FDFS_PROTO_PKG_LEN_SIZE;
+  public static final int TRACKER_QUERY_STORAGE_STORE_IPV4_BODY_LEN = FDFS_GROUP_NAME_MAX_LEN
+    + FDFS_IPV4_SIZE + FDFS_PROTO_PKG_LEN_SIZE;
+  public static final int TRACKER_QUERY_STORAGE_STORE_IPV6_BODY_LEN = FDFS_GROUP_NAME_MAX_LEN
+    + FDFS_IPV6_SIZE + FDFS_PROTO_PKG_LEN_SIZE;
   public static final byte FDFS_FILE_EXT_NAME_MAX_LEN = 6;
   public static final byte FDFS_FILE_PREFIX_MAX_LEN = 16;
   public static final byte FDFS_FILE_PATH_LEN = 10;
@@ -102,6 +107,15 @@ public class ProtoCommon {
   protected static final int PROTO_HEADER_CMD_INDEX = FDFS_PROTO_PKG_LEN_SIZE;
   protected static final int PROTO_HEADER_STATUS_INDEX = FDFS_PROTO_PKG_LEN_SIZE + 1;
 
+  //read write mode
+  public static final byte FDFS_RW_MODE_NONE = 0;
+  public static final byte FDFS_RW_MODE_READONLY = 4;
+  public static final byte FDFS_RW_MODE_WRITEONLY = 2;
+  public static final byte FDFS_RW_MODE_BOTH = FDFS_RW_MODE_READONLY + FDFS_RW_MODE_WRITEONLY;
+
+  public static final byte FDFS_QUERY_FINFO_FLAGS_NOT_CALC_CRC32 = 1;
+  public static final byte FDFS_QUERY_FINFO_FLAGS_KEEP_SILENCE   = 2;
+
   private ProtoCommon() {
   }
 
@@ -310,6 +324,23 @@ public class ProtoCommon {
     return headerInfo.errno == 0 ? true : false;
   }
 
+  /**
+   * int convert to buff (big-endian)
+   *
+   * @param n int number
+   * @return 4 bytes buff
+   */
+  public static byte[] int2buff(int n) {
+      byte[] bs;
+
+      bs = new byte[4];
+      bs[0] = (byte) ((n >> 24) & 0xFF);
+      bs[1] = (byte) ((n >> 16) & 0xFF);
+      bs[2] = (byte) ((n >> 8) & 0xFF);
+      bs[3] = (byte) (n & 0xFF);
+      return bs;
+  }
+
   /**
    * long convert to buff (big-endian)
    *
@@ -317,19 +348,18 @@ public class ProtoCommon {
    * @return 8 bytes buff
    */
   public static byte[] long2buff(long n) {
-    byte[] bs;
+      byte[] bs;
 
-    bs = new byte[8];
-    bs[0] = (byte) ((n >> 56) & 0xFF);
-    bs[1] = (byte) ((n >> 48) & 0xFF);
-    bs[2] = (byte) ((n >> 40) & 0xFF);
-    bs[3] = (byte) ((n >> 32) & 0xFF);
-    bs[4] = (byte) ((n >> 24) & 0xFF);
-    bs[5] = (byte) ((n >> 16) & 0xFF);
-    bs[6] = (byte) ((n >> 8) & 0xFF);
-    bs[7] = (byte) (n & 0xFF);
-
-    return bs;
+      bs = new byte[8];
+      bs[0] = (byte) ((n >> 56) & 0xFF);
+      bs[1] = (byte) ((n >> 48) & 0xFF);
+      bs[2] = (byte) ((n >> 40) & 0xFF);
+      bs[3] = (byte) ((n >> 32) & 0xFF);
+      bs[4] = (byte) ((n >> 24) & 0xFF);
+      bs[5] = (byte) ((n >> 16) & 0xFF);
+      bs[6] = (byte) ((n >> 8) & 0xFF);
+      bs[7] = (byte) (n & 0xFF);
+      return bs;
   }
 
   /**

src/main/java/org/csource/fastdfs/StorageAddressMap.java

@@ -0,0 +1,62 @@
+/**
+ * Copyright (C) 2023 Happy Fish / YuQing
+ * <p>
+ * FastDFS Java Client may be copied only under the terms of the GNU Lesser
+ * General Public License (LGPL).
+ * Please visit the FastDFS Home Page https://github.com/happyfish100/fastdfs for more detail.
+ */
+
+package org.csource.fastdfs;
+
+import java.util.HashMap;
+import java.net.InetSocketAddress;
+
+/**
+ * Storage Server Address Map
+ *
+ * @author Happy Fish / YuQing
+ * @version Version 1.31
+ */
+public class StorageAddressMap {
+
+    protected boolean without_port;
+    protected HashMap<String, InetSocketAddress> storages;
+
+    public StorageAddressMap(boolean without_port) {
+        this.without_port = without_port;
+        this.storages = new HashMap<String, InetSocketAddress>();
+    }
+
+    protected String getKey(String ipAddr, int port) {
+        return ipAddr + "@" + port;
+    }
+
+    public void puts(String srcIpAddr, String destIpAddr, int port) {
+        storages.put(this.getKey(srcIpAddr, port),
+                new InetSocketAddress(destIpAddr, port));
+        storages.put(this.getKey(destIpAddr, port),
+                new InetSocketAddress(srcIpAddr, port));
+    }
+
+    public void puts(String srcIpAddr, String destIpAddr) {
+        storages.put(srcIpAddr, new InetSocketAddress(destIpAddr, 0));
+        storages.put(destIpAddr, new InetSocketAddress(srcIpAddr, 0));
+    }
+
+    public InetSocketAddress get(String ipAddr, int port) {
+        if (this.without_port) {
+            InetSocketAddress sockAddr;
+            if ((sockAddr=storages.get(ipAddr)) == null) {
+                return null;
+            }
+
+            return new InetSocketAddress(sockAddr.getAddress(), port);
+        } else {
+            return storages.get(this.getKey(ipAddr, port));
+        }
+    }
+
+    public InetSocketAddress get(InetSocketAddress sockAddr) {
+        return this.get(sockAddr.getAddress().getHostAddress(), sockAddr.getPort());
+    }
+}

src/main/java/org/csource/fastdfs/StorageClient.java

@@ -847,7 +847,6 @@ public class StorageClient {
             throw ex;
         } finally {
             releaseConnection(connection, bNewStorageServer);
-
         }
     }
 
@@ -1541,9 +1540,14 @@ public class StorageClient {
      *
      * @param group_name      the group name of storage server
      * @param remote_filename filename on storage server
+     * @param flags combined flags as following:
+     *             ProtoCommon.FDFS_QUERY_FINFO_FLAGS_NOT_CALC_CRC32 : do NOT calculate CRC32
+     *                  for appender file or slave file
+     *             ProtoCommon.FDFS_QUERY_FINFO_FLAGS_KEEP_SILENCE   : keep silence,
+     *                  when this file not exist, do not log error on storage server
      * @return FileInfo object for success, return null for fail
      */
-    public FileInfo query_file_info(String group_name, String remote_filename) throws IOException, MyException {
+    public FileInfo query_file_info(String group_name, String remote_filename, byte flags) throws IOException, MyException {
         boolean bNewStorageServer = this.newUpdatableStorageConnection(group_name, remote_filename);
         Connection connection = this.storageServer.getConnection();
         try {
@@ -1567,7 +1571,7 @@ public class StorageClient {
             System.arraycopy(bs, 0, groupBytes, 0, groupLen);
 
             header = ProtoCommon.packHeader(ProtoCommon.STORAGE_PROTO_CMD_QUERY_FILE_INFO,
-                    +groupBytes.length + filenameBytes.length, (byte) 0);
+                    groupBytes.length + filenameBytes.length, flags);
             OutputStream out = connection.getOutputStream();
             byte[] wholePkg = new byte[header.length + groupBytes.length + filenameBytes.length];
             System.arraycopy(header, 0, wholePkg, 0, header.length);
@@ -1576,19 +1580,28 @@ public class StorageClient {
             out.write(wholePkg);
 
             pkgInfo = ProtoCommon.recvPackage(connection.getInputStream(),
-                    ProtoCommon.STORAGE_PROTO_CMD_RESP,
-                    3 * ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE +
-                            ProtoCommon.FDFS_IPADDR_SIZE);
+                    ProtoCommon.STORAGE_PROTO_CMD_RESP, -1);
 
             this.errno = pkgInfo.errno;
             if (pkgInfo.errno != 0) {
                 return null;
             }
 
+            int front_len = 3 * ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+            int ip_size;
+            if (pkgInfo.body.length == front_len + ProtoCommon.FDFS_IPV6_SIZE) { //IPv6
+                ip_size = ProtoCommon.FDFS_IPV6_SIZE;
+            } else if (pkgInfo.body.length == front_len + ProtoCommon.FDFS_IPV4_SIZE) { //IPv4
+                ip_size = ProtoCommon.FDFS_IPV4_SIZE;
+            } else {
+                this.errno = ProtoCommon.ERR_NO_EINVAL;
+                throw new IOException("Invalid body length: " + pkgInfo.body.length);
+            }
+
             long file_size = ProtoCommon.buff2long(pkgInfo.body, 0);
             int create_timestamp = (int) ProtoCommon.buff2long(pkgInfo.body, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
             int crc32 = (int) ProtoCommon.buff2long(pkgInfo.body, 2 * ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-            String source_ip_addr = (new String(pkgInfo.body, 3 * ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE, ProtoCommon.FDFS_IPADDR_SIZE)).trim();
+            String source_ip_addr = (new String(pkgInfo.body, front_len, ip_size)).trim();
             return new FileInfo(true, FileInfo.FILE_TYPE_NORMAL, file_size,
                     create_timestamp, crc32, source_ip_addr);
         } catch (IOException ex) {
@@ -1605,6 +1618,11 @@ public class StorageClient {
         }
     }
 
+    public FileInfo query_file_info(String group_name, String remote_filename) throws IOException, MyException {
+        final byte flags = 0;
+        return this.query_file_info(group_name, remote_filename, flags);
+    }
+
     /**
      * check storage socket, if null create a new connection
      *

src/main/java/org/csource/fastdfs/StorageClient1.java

@@ -735,16 +735,26 @@ public class StorageClient1 extends StorageClient {
    * get file info from storage server
    *
    * @param file_id the file id(including group name and filename)
+   * @param flags combined flags as following:
+   *             ProtoCommon.FDFS_QUERY_FINFO_FLAGS_NOT_CALC_CRC32 : do NOT calculate CRC32
+   *                  for appender file or slave file
+   *             ProtoCommon.FDFS_QUERY_FINFO_FLAGS_KEEP_SILENCE   : keep silence,
+   *                  when this file not exist, do not log error on storage server
    * @return FileInfo object for success, return null for fail
    */
-  public FileInfo query_file_info1(String file_id) throws IOException, MyException {
-    String[] parts = new String[2];
-    this.errno = this.split_file_id(file_id, parts);
-    if (this.errno != 0) {
-      return null;
-    }
+  public FileInfo query_file_info1(String file_id, byte flags) throws IOException, MyException {
+      String[] parts = new String[2];
+      this.errno = this.split_file_id(file_id, parts);
+      if (this.errno != 0) {
+          return null;
+      }
 
-    return this.query_file_info(parts[0], parts[1]);
+      return this.query_file_info(parts[0], parts[1], flags);
+  }
+
+  public FileInfo query_file_info1(String file_id) throws IOException, MyException {
+      final byte flags = 0;
+      return this.query_file_info1(file_id, flags);
   }
 
   /**

src/main/java/org/csource/fastdfs/StorageServer.java

@@ -9,6 +9,9 @@
 package org.csource.fastdfs;
 
 import java.io.IOException;
+import java.util.Hashtable;
+import org.csource.common.MyException;
+import org.csource.fastdfs.pool.Connection;
 import java.net.InetSocketAddress;
 
 /**
@@ -18,40 +21,112 @@ import java.net.InetSocketAddress;
  * @version Version 1.11
  */
 public class StorageServer extends TrackerServer {
-  protected int store_path_index = 0;
+    protected int store_path_index = 0;
 
-  /**
-   * Constructor
-   *
-   * @param ip_addr    the ip address of storage server
-   * @param port       the port of storage server
-   * @param store_path the store path index on the storage server
-   */
-  public StorageServer(String ip_addr, int port, int store_path) throws IOException {
-    super(new InetSocketAddress(ip_addr, port));
-    this.store_path_index = store_path;
-  }
+    protected static Hashtable<String, InetSocketAddress> sockAddressCache = new Hashtable<String, InetSocketAddress>();
 
-  /**
-   * Constructor
-   *
-   * @param ip_addr    the ip address of storage server
-   * @param port       the port of storage server
-   * @param store_path the store path index on the storage server
-   */
-  public StorageServer(String ip_addr, int port, byte store_path) throws IOException {
-    super(new InetSocketAddress(ip_addr, port));
-    if (store_path < 0) {
-      this.store_path_index = 256 + store_path;
-    } else {
-      this.store_path_index = store_path;
+    /**
+     * Constructor
+     *
+     * @param ip_addr    the ip address of storage server
+     * @param port       the port of storage server
+     * @param store_path the store path index on the storage server
+     */
+    public StorageServer(String ip_addr, int port, int store_path) throws IOException {
+        super(new InetSocketAddress(ip_addr, port));
+        this.store_path_index = store_path;
     }
-  }
 
-  /**
-   * @return the store path index on the storage server
-   */
-  public int getStorePathIndex() {
-    return this.store_path_index;
-  }
+    /**
+     * Constructor
+     *
+     * @param ip_addr    the ip address of storage server
+     * @param port       the port of storage server
+     * @param store_path the store path index on the storage server
+     */
+    public StorageServer(String ip_addr, int port, byte store_path) throws IOException {
+        super(new InetSocketAddress(ip_addr, port));
+        if (store_path < 0) {
+            this.store_path_index = 256 + store_path;
+        } else {
+            this.store_path_index = store_path;
+        }
+    }
+
+    /**
+     * @return the store path index on the storage server
+     */
+    public int getStorePathIndex() {
+        return this.store_path_index;
+    }
+
+    public Connection getConnection() throws MyException, IOException {
+        Connection connection;
+        InetSocketAddress sockAddr;
+        MyException myException = null;
+        IOException ioException = null;
+
+        if (!ClientGlobal.g_multi_storage_ips) {
+            return super.getConnection();
+        }
+
+        if (ClientGlobal.g_connect_first_by == ClientGlobal.CONNECT_FIRST_BY_TRACKER) {
+            try {
+                if ((connection=super.getConnection()) != null) {
+                    return connection;
+                }
+            } catch (MyException ex1) {
+                myException = ex1;
+            } catch (IOException ex2) {
+                ioException = ex2;
+            }
+
+            sockAddr = ClientGlobal.g_storages_address_map.get(this.inetSockAddr);
+            if (sockAddr != null) {
+                return super.getConnection(sockAddr);
+            } else if (myException != null) {
+                throw myException;
+            } else if (ioException != null) {
+                throw ioException;
+            }
+        } else {
+            String key = this.inetSockAddr.getAddress().getHostAddress() +
+                "@" + this.inetSockAddr.getPort();
+            sockAddr = sockAddressCache.get(key);
+            try {
+                if (sockAddr == null) {
+                    sockAddr = this.inetSockAddr;
+                    if ((connection=super.getConnection(sockAddr)) != null) {
+                        sockAddressCache.put(key, sockAddr);
+                        return connection;
+                    }
+                } else {
+                    if ((connection=super.getConnection(sockAddr)) != null) {
+                        return connection;
+                    }
+                }
+            } catch (MyException ex1) {
+                myException = ex1;
+            } catch (IOException ex2) {
+                ioException = ex2;
+            }
+
+            //retry another ip address
+            if ((sockAddr=ClientGlobal.g_storages_address_map.get(sockAddr)) == null) {
+                if (myException != null) {
+                    throw myException;
+                } else if (ioException != null) {
+                    throw ioException;
+                }
+                return null;
+            }
+
+            if ((connection=super.getConnection(sockAddr)) != null) {
+                sockAddressCache.put(key, sockAddr);
+                return connection;
+            }
+        }
+
+        return null;
+    }
 }

src/main/java/org/csource/fastdfs/StructGroupStat.java

@@ -12,74 +12,94 @@ package org.csource.fastdfs;
  * C struct body decoder
  *
  * @author Happy Fish / YuQing
- * @version Version 1.18
+ * @version Version 1.34
  */
 public class StructGroupStat extends StructBase {
   protected static final int FIELD_INDEX_GROUP_NAME = 0;
   protected static final int FIELD_INDEX_TOTAL_MB = 1;
   protected static final int FIELD_INDEX_FREE_MB = 2;
-  protected static final int FIELD_INDEX_TRUNK_FREE_MB = 3;
-  protected static final int FIELD_INDEX_STORAGE_COUNT = 4;
-  protected static final int FIELD_INDEX_STORAGE_PORT = 5;
-  protected static final int FIELD_INDEX_STORAGE_HTTP_PORT = 6;
-  protected static final int FIELD_INDEX_ACTIVE_COUNT = 7;
-  protected static final int FIELD_INDEX_CURRENT_WRITE_SERVER = 8;
-  protected static final int FIELD_INDEX_STORE_PATH_COUNT = 9;
-  protected static final int FIELD_INDEX_SUBDIR_COUNT_PER_PATH = 10;
-  protected static final int FIELD_INDEX_CURRENT_TRUNK_FILE_ID = 11;
+  protected static final int FIELD_INDEX_RESERVED_MB = 3;
+  protected static final int FIELD_INDEX_TRUNK_FREE_MB = 4;
+  protected static final int FIELD_INDEX_STORAGE_COUNT = 5;
+  protected static final int FIELD_INDEX_STORAGE_PORT = 6;
+  protected static final int FIELD_INDEX_READABLE_SERVER_COUNT = 7;
+  protected static final int FIELD_INDEX_WRITABLE_SERVER_COUNT = 8;
+  protected static final int FIELD_INDEX_CURRENT_WRITE_SERVER = 9;
+  protected static final int FIELD_INDEX_STORE_PATH_COUNT = 10;
+  protected static final int FIELD_INDEX_SUBDIR_COUNT_PER_PATH = 11;
+  protected static final int FIELD_INDEX_CURRENT_TRUNK_FILE_ID = 12;
+
+  protected static final int FIELD_COUNT = 13;
 
   protected static int fieldsTotalSize;
-  protected static StructBase.FieldInfo[] fieldsArray = new StructBase.FieldInfo[12];
+  protected static StructBase.FieldInfo[] fieldsArray = new StructBase.FieldInfo[FIELD_COUNT];
 
   static {
     int offset = 0;
-    fieldsArray[FIELD_INDEX_GROUP_NAME] = new StructBase.FieldInfo("groupName", offset, ProtoCommon.FDFS_GROUP_NAME_MAX_LEN + 1);
+    fieldsArray[FIELD_INDEX_GROUP_NAME] = new StructBase.FieldInfo(
+            "groupName", offset, ProtoCommon.FDFS_GROUP_NAME_MAX_LEN + 1);
     offset += ProtoCommon.FDFS_GROUP_NAME_MAX_LEN + 1;
 
-    fieldsArray[FIELD_INDEX_TOTAL_MB] = new StructBase.FieldInfo("totalMB", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+    fieldsArray[FIELD_INDEX_TOTAL_MB] = new StructBase.FieldInfo(
+            "totalMB", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
     offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_FREE_MB] = new StructBase.FieldInfo("freeMB", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+    fieldsArray[FIELD_INDEX_FREE_MB] = new StructBase.FieldInfo(
+            "freeMB", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
     offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TRUNK_FREE_MB] = new StructBase.FieldInfo("trunkFreeMB", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+    fieldsArray[FIELD_INDEX_RESERVED_MB] = new StructBase.FieldInfo(
+            "reservedMB", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
     offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_STORAGE_COUNT] = new StructBase.FieldInfo("storageCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+    fieldsArray[FIELD_INDEX_TRUNK_FREE_MB] = new StructBase.FieldInfo(
+            "trunkFreeMB", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
     offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_STORAGE_PORT] = new StructBase.FieldInfo("storagePort", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+    fieldsArray[FIELD_INDEX_STORAGE_COUNT] = new StructBase.FieldInfo(
+            "storageCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
     offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_STORAGE_HTTP_PORT] = new StructBase.FieldInfo("storageHttpPort", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+    fieldsArray[FIELD_INDEX_STORAGE_PORT] = new StructBase.FieldInfo(
+            "storagePort", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
     offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_ACTIVE_COUNT] = new StructBase.FieldInfo("activeCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+    fieldsArray[FIELD_INDEX_READABLE_SERVER_COUNT] = new StructBase.FieldInfo(
+            "readableServerCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
     offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_CURRENT_WRITE_SERVER] = new StructBase.FieldInfo("currentWriteServer", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+    fieldsArray[FIELD_INDEX_WRITABLE_SERVER_COUNT] = new StructBase.FieldInfo(
+            "writableServerCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
     offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_STORE_PATH_COUNT] = new StructBase.FieldInfo("storePathCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+    fieldsArray[FIELD_INDEX_CURRENT_WRITE_SERVER] = new StructBase.FieldInfo(
+            "currentWriteServer", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
     offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUBDIR_COUNT_PER_PATH] = new StructBase.FieldInfo("subdirCountPerPath", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+    fieldsArray[FIELD_INDEX_STORE_PATH_COUNT] = new StructBase.FieldInfo(
+            "storePathCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
     offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_CURRENT_TRUNK_FILE_ID] = new StructBase.FieldInfo("currentTrunkFileId", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+    fieldsArray[FIELD_INDEX_SUBDIR_COUNT_PER_PATH] = new StructBase.FieldInfo(
+            "subdirCountPerPath", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+
+    fieldsArray[FIELD_INDEX_CURRENT_TRUNK_FILE_ID] = new StructBase.FieldInfo(
+            "currentTrunkFileId", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
     offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
     fieldsTotalSize = offset;
   }
 
   protected String groupName;  //name of this group
-  protected long totalMB;      //total disk storage in MB
+  protected long totalMB;      //total disk space in MB
   protected long freeMB;       //free disk space in MB
+  protected long reservedMB;   //reserved disk space in MB
   protected long trunkFreeMB;  //trunk free space in MB
   protected int storageCount;  //storage server count
   protected int storagePort;   //storage server port
-  protected int storageHttpPort; //storage server HTTP port
-  protected int activeCount;     //active storage server count
+  protected int readableServerCount; //readable storage server count
+  protected int writableServerCount; //writable storage server count
   protected int currentWriteServer; //current storage server index to upload file
   protected int storePathCount;     //store base path count of each storage server
   protected int subdirCountPerPath; //sub dir count per store path
@@ -121,6 +141,15 @@ public class StructGroupStat extends StructBase {
     return this.freeMB;
   }
 
+  /**
+   * get reserved disk space in MB
+   *
+   * @return reserved disk space in MB
+   */
+  public long getReservedMB() {
+    return this.reservedMB;
+  }
+
   /**
    * get trunk free space in MB
    *
@@ -139,13 +168,22 @@ public class StructGroupStat extends StructBase {
     return this.storageCount;
   }
 
+  /**
+   * get readable storage server count
+   *
+   * @return readable storage server count
+   */
+  public int getReadableServerCount() {
+    return this.readableServerCount;
+  }
+
   /**
    * get active storage server count in this group
    *
    * @return active storage server count in this group
    */
-  public int getActiveCount() {
-    return this.activeCount;
+  public int getWritableServerCount() {
+    return this.writableServerCount;
   }
 
   /**
@@ -157,15 +195,6 @@ public class StructGroupStat extends StructBase {
     return this.storagePort;
   }
 
-  /**
-   * get storage server HTTP port
-   *
-   * @return storage server HTTP port
-   */
-  public int getStorageHttpPort() {
-    return this.storageHttpPort;
-  }
-
   /**
    * get current storage server index to upload file
    *
@@ -212,11 +241,12 @@ public class StructGroupStat extends StructBase {
     this.groupName = stringValue(bs, offset, fieldsArray[FIELD_INDEX_GROUP_NAME]);
     this.totalMB = longValue(bs, offset, fieldsArray[FIELD_INDEX_TOTAL_MB]);
     this.freeMB = longValue(bs, offset, fieldsArray[FIELD_INDEX_FREE_MB]);
+    this.reservedMB = longValue(bs, offset, fieldsArray[FIELD_INDEX_RESERVED_MB]);
     this.trunkFreeMB = longValue(bs, offset, fieldsArray[FIELD_INDEX_TRUNK_FREE_MB]);
     this.storageCount = intValue(bs, offset, fieldsArray[FIELD_INDEX_STORAGE_COUNT]);
     this.storagePort = intValue(bs, offset, fieldsArray[FIELD_INDEX_STORAGE_PORT]);
-    this.storageHttpPort = intValue(bs, offset, fieldsArray[FIELD_INDEX_STORAGE_HTTP_PORT]);
-    this.activeCount = intValue(bs, offset, fieldsArray[FIELD_INDEX_ACTIVE_COUNT]);
+    this.readableServerCount = intValue(bs, offset, fieldsArray[FIELD_INDEX_READABLE_SERVER_COUNT]);
+    this.writableServerCount = intValue(bs, offset, fieldsArray[FIELD_INDEX_WRITABLE_SERVER_COUNT]);
     this.currentWriteServer = intValue(bs, offset, fieldsArray[FIELD_INDEX_CURRENT_WRITE_SERVER]);
     this.storePathCount = intValue(bs, offset, fieldsArray[FIELD_INDEX_STORE_PATH_COUNT]);
     this.subdirCountPerPath = intValue(bs, offset, fieldsArray[FIELD_INDEX_SUBDIR_COUNT_PER_PATH]);

src/main/java/org/csource/fastdfs/StructIPv4StorageStat.java

@@ -0,0 +1,46 @@
+/**
+ * Copyright (C) 2025 Happy Fish / YuQing
+ * <p>
+ * FastDFS Java Client may be copied only under the terms of the GNU Lesser
+ * General Public License (LGPL).
+ * Please visit the FastDFS Home Page https://github.com/happyfish100/fastdfs for more detail.
+ */
+
+package org.csource.fastdfs;
+
+import java.util.Date;
+
+/**
+ * C struct body decoder
+ *
+ * @author Happy Fish / YuQing
+ * @version Version 1.36
+ */
+public class StructIPv4StorageStat extends StructStorageStat {
+  protected static int fieldsTotalSize;
+  protected static StructBase.FieldInfo[] fieldsArray =
+      new StructBase.FieldInfo[StructStorageStat.FIELD_COUNT];
+
+  static {
+      fieldsTotalSize = StructStorageStat.initFieldsArray(
+              fieldsArray, ProtoCommon.FDFS_IPV4_SIZE);
+  }
+
+  /**
+   * get fields total size
+   *
+   * @return fields total size
+   */
+  public static int getFieldsTotalSize() {
+    return fieldsTotalSize;
+  }
+
+  /**
+   *
+   * @param bs     byte array
+   * @param offset start offset
+   */
+  public void setFields(byte[] bs, int offset) {
+      super.setFields(fieldsArray, bs, offset);
+  }
+}

src/main/java/org/csource/fastdfs/StructIPv6StorageStat.java

@@ -0,0 +1,46 @@
+/**
+ * Copyright (C) 2025 Happy Fish / YuQing
+ * <p>
+ * FastDFS Java Client may be copied only under the terms of the GNU Lesser
+ * General Public License (LGPL).
+ * Please visit the FastDFS Home Page https://github.com/happyfish100/fastdfs for more detail.
+ */
+
+package org.csource.fastdfs;
+
+import java.util.Date;
+
+/**
+ * C struct body decoder
+ *
+ * @author Happy Fish / YuQing
+ * @version Version 1.36
+ */
+public class StructIPv6StorageStat extends StructStorageStat {
+  protected static int fieldsTotalSize;
+  protected static StructBase.FieldInfo[] fieldsArray =
+      new StructBase.FieldInfo[StructStorageStat.FIELD_COUNT];
+
+  static {
+      fieldsTotalSize = StructStorageStat.initFieldsArray(
+              fieldsArray, ProtoCommon.FDFS_IPV6_SIZE);
+  }
+
+  /**
+   * get fields total size
+   *
+   * @return fields total size
+   */
+  public static int getFieldsTotalSize() {
+    return fieldsTotalSize;
+  }
+
+  /**
+   *
+   * @param bs     byte array
+   * @param offset start offset
+   */
+  public void setFields(byte[] bs, int offset) {
+      super.setFields(fieldsArray, bs, offset);
+  }
+}

src/main/java/org/csource/fastdfs/StructStorageStat.java

@@ -14,25 +14,26 @@ import java.util.Date;
  * C struct body decoder
  *
  * @author Happy Fish / YuQing
- * @version Version 1.25
+ * @version Version 1.35
  */
 public class StructStorageStat extends StructBase {
   protected static final int FIELD_INDEX_STATUS = 0;
-  protected static final int FIELD_INDEX_ID = 1;
-  protected static final int FIELD_INDEX_IP_ADDR = 2;
-  protected static final int FIELD_INDEX_DOMAIN_NAME = 3;
-  protected static final int FIELD_INDEX_SRC_IP_ADDR = 4;
+  protected static final int FIELD_INDEX_RW_MODE = 1;
+  protected static final int FIELD_INDEX_ID = 2;
+  protected static final int FIELD_INDEX_IP_ADDR = 3;
+  protected static final int FIELD_INDEX_SRC_ID = 4;
   protected static final int FIELD_INDEX_VERSION = 5;
   protected static final int FIELD_INDEX_JOIN_TIME = 6;
   protected static final int FIELD_INDEX_UP_TIME = 7;
   protected static final int FIELD_INDEX_TOTAL_MB = 8;
   protected static final int FIELD_INDEX_FREE_MB = 9;
-  protected static final int FIELD_INDEX_UPLOAD_PRIORITY = 10;
-  protected static final int FIELD_INDEX_STORE_PATH_COUNT = 11;
-  protected static final int FIELD_INDEX_SUBDIR_COUNT_PER_PATH = 12;
-  protected static final int FIELD_INDEX_CURRENT_WRITE_PATH = 13;
-  protected static final int FIELD_INDEX_STORAGE_PORT = 14;
-  protected static final int FIELD_INDEX_STORAGE_HTTP_PORT = 15;
+  protected static final int FIELD_INDEX_RESERVED_MB = 10;
+
+  protected static final int FIELD_INDEX_UPLOAD_PRIORITY = 11;
+  protected static final int FIELD_INDEX_STORE_PATH_COUNT = 12;
+  protected static final int FIELD_INDEX_SUBDIR_COUNT_PER_PATH = 13;
+  protected static final int FIELD_INDEX_CURRENT_WRITE_PATH = 14;
+  protected static final int FIELD_INDEX_STORAGE_PORT = 15;
 
   protected static final int FIELD_INDEX_CONNECTION_ALLOC_COUNT = 16;
   protected static final int FIELD_INDEX_CONNECTION_CURRENT_COUNT = 17;
@@ -82,216 +83,277 @@ public class StructStorageStat extends StructBase {
   protected static final int FIELD_INDEX_LAST_HEART_BEAT_TIME = 60;
   protected static final int FIELD_INDEX_IF_TRUNK_FILE = 61;
 
-  protected static int fieldsTotalSize;
-  protected static StructBase.FieldInfo[] fieldsArray = new StructBase.FieldInfo[62];
+  protected static final int FIELD_COUNT = 62;
 
-  static {
-    int offset = 0;
+  protected static int initFieldsArray(StructBase.FieldInfo[] fieldsArray, int ipaddr_size) {
+      int offset = 0;
 
-    fieldsArray[FIELD_INDEX_STATUS] = new StructBase.FieldInfo("status", offset, 1);
-    offset += 1;
+      fieldsArray[FIELD_INDEX_STATUS] = new StructBase.FieldInfo(
+              "status", offset, 1);
+      offset += 1;
 
-    fieldsArray[FIELD_INDEX_ID] = new StructBase.FieldInfo("id", offset, ProtoCommon.FDFS_STORAGE_ID_MAX_SIZE);
-    offset += ProtoCommon.FDFS_STORAGE_ID_MAX_SIZE;
+      fieldsArray[FIELD_INDEX_RW_MODE] = new StructBase.FieldInfo(
+              "readWriteMode", offset, 1);
+      offset += 1;
 
-    fieldsArray[FIELD_INDEX_IP_ADDR] = new StructBase.FieldInfo("ipAddr", offset, ProtoCommon.FDFS_IPADDR_SIZE);
-    offset += ProtoCommon.FDFS_IPADDR_SIZE;
+      fieldsArray[FIELD_INDEX_ID] = new StructBase.FieldInfo(
+              "id", offset, ProtoCommon.FDFS_STORAGE_ID_MAX_SIZE);
+      offset += ProtoCommon.FDFS_STORAGE_ID_MAX_SIZE;
 
-    fieldsArray[FIELD_INDEX_DOMAIN_NAME] = new StructBase.FieldInfo("domainName", offset, ProtoCommon.FDFS_DOMAIN_NAME_MAX_SIZE);
-    offset += ProtoCommon.FDFS_DOMAIN_NAME_MAX_SIZE;
+      fieldsArray[FIELD_INDEX_IP_ADDR] = new StructBase.FieldInfo(
+              "ipAddr", offset, ipaddr_size);
+      offset += ipaddr_size;
 
-    fieldsArray[FIELD_INDEX_SRC_IP_ADDR] = new StructBase.FieldInfo("srcIpAddr", offset, ProtoCommon.FDFS_IPADDR_SIZE);
-    offset += ProtoCommon.FDFS_IPADDR_SIZE;
+      fieldsArray[FIELD_INDEX_SRC_ID] = new StructBase.FieldInfo(
+              "srcId", offset, ProtoCommon.FDFS_STORAGE_ID_MAX_SIZE);
+      offset += ProtoCommon.FDFS_STORAGE_ID_MAX_SIZE;
 
-    fieldsArray[FIELD_INDEX_VERSION] = new StructBase.FieldInfo("version", offset, ProtoCommon.FDFS_VERSION_SIZE);
-    offset += ProtoCommon.FDFS_VERSION_SIZE;
+      fieldsArray[FIELD_INDEX_VERSION] = new StructBase.FieldInfo(
+              "version", offset, ProtoCommon.FDFS_VERSION_SIZE);
+      offset += ProtoCommon.FDFS_VERSION_SIZE;
 
-    fieldsArray[FIELD_INDEX_JOIN_TIME] = new StructBase.FieldInfo("joinTime", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_JOIN_TIME] = new StructBase.FieldInfo(
+              "joinTime", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_UP_TIME] = new StructBase.FieldInfo("upTime", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_UP_TIME] = new StructBase.FieldInfo(
+              "upTime", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_MB] = new StructBase.FieldInfo("totalMB", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_MB] = new StructBase.FieldInfo(
+              "totalMB", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_FREE_MB] = new StructBase.FieldInfo("freeMB", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_FREE_MB] = new StructBase.FieldInfo(
+              "freeMB", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_UPLOAD_PRIORITY] = new StructBase.FieldInfo("uploadPriority", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_RESERVED_MB] = new StructBase.FieldInfo(
+              "reservedMB", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_STORE_PATH_COUNT] = new StructBase.FieldInfo("storePathCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_UPLOAD_PRIORITY] = new StructBase.FieldInfo(
+              "uploadPriority", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUBDIR_COUNT_PER_PATH] = new StructBase.FieldInfo("subdirCountPerPath", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_STORE_PATH_COUNT] = new StructBase.FieldInfo(
+              "storePathCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_CURRENT_WRITE_PATH] = new StructBase.FieldInfo("currentWritePath", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUBDIR_COUNT_PER_PATH] = new StructBase.FieldInfo(
+              "subdirCountPerPath", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_STORAGE_PORT] = new StructBase.FieldInfo("storagePort", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_CURRENT_WRITE_PATH] = new StructBase.FieldInfo(
+              "currentWritePath", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_STORAGE_HTTP_PORT] = new StructBase.FieldInfo("storageHttpPort", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_STORAGE_PORT] = new StructBase.FieldInfo(
+              "storagePort", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_CONNECTION_ALLOC_COUNT] = new StructBase.FieldInfo("connectionAllocCount", offset, 4);
-    offset += 4;
+      fieldsArray[FIELD_INDEX_CONNECTION_ALLOC_COUNT] = new StructBase.FieldInfo(
+              "connectionAllocCount", offset, 4);
+      offset += 4;
 
-    fieldsArray[FIELD_INDEX_CONNECTION_CURRENT_COUNT] = new StructBase.FieldInfo("connectionCurrentCount", offset, 4);
-    offset += 4;
+      fieldsArray[FIELD_INDEX_CONNECTION_CURRENT_COUNT] = new StructBase.FieldInfo(
+              "connectionCurrentCount", offset, 4);
+      offset += 4;
 
-    fieldsArray[FIELD_INDEX_CONNECTION_MAX_COUNT] = new StructBase.FieldInfo("connectionMaxCount", offset, 4);
-    offset += 4;
+      fieldsArray[FIELD_INDEX_CONNECTION_MAX_COUNT] = new StructBase.FieldInfo(
+              "connectionMaxCount", offset, 4);
+      offset += 4;
 
-    fieldsArray[FIELD_INDEX_TOTAL_UPLOAD_COUNT] = new StructBase.FieldInfo("totalUploadCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_UPLOAD_COUNT] = new StructBase.FieldInfo(
+              "totalUploadCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_UPLOAD_COUNT] = new StructBase.FieldInfo("successUploadCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_UPLOAD_COUNT] = new StructBase.FieldInfo(
+              "successUploadCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_APPEND_COUNT] = new StructBase.FieldInfo("totalAppendCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_APPEND_COUNT] = new StructBase.FieldInfo(
+              "totalAppendCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_APPEND_COUNT] = new StructBase.FieldInfo("successAppendCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_APPEND_COUNT] = new StructBase.FieldInfo(
+              "successAppendCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_MODIFY_COUNT] = new StructBase.FieldInfo("totalModifyCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_MODIFY_COUNT] = new StructBase.FieldInfo(
+              "totalModifyCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_MODIFY_COUNT] = new StructBase.FieldInfo("successModifyCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_MODIFY_COUNT] = new StructBase.FieldInfo(
+              "successModifyCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_TRUNCATE_COUNT] = new StructBase.FieldInfo("totalTruncateCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_TRUNCATE_COUNT] = new StructBase.FieldInfo(
+              "totalTruncateCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_TRUNCATE_COUNT] = new StructBase.FieldInfo("successTruncateCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_TRUNCATE_COUNT] = new StructBase.FieldInfo(
+              "successTruncateCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_SET_META_COUNT] = new StructBase.FieldInfo("totalSetMetaCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_SET_META_COUNT] = new StructBase.FieldInfo(
+              "totalSetMetaCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_SET_META_COUNT] = new StructBase.FieldInfo("successSetMetaCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_SET_META_COUNT] = new StructBase.FieldInfo(
+              "successSetMetaCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_DELETE_COUNT] = new StructBase.FieldInfo("totalDeleteCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_DELETE_COUNT] = new StructBase.FieldInfo(
+              "totalDeleteCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_DELETE_COUNT] = new StructBase.FieldInfo("successDeleteCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_DELETE_COUNT] = new StructBase.FieldInfo(
+              "successDeleteCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_DOWNLOAD_COUNT] = new StructBase.FieldInfo("totalDownloadCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_DOWNLOAD_COUNT] = new StructBase.FieldInfo(
+              "totalDownloadCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_DOWNLOAD_COUNT] = new StructBase.FieldInfo("successDownloadCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_DOWNLOAD_COUNT] = new StructBase.FieldInfo(
+              "successDownloadCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_GET_META_COUNT] = new StructBase.FieldInfo("totalGetMetaCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_GET_META_COUNT] = new StructBase.FieldInfo(
+              "totalGetMetaCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_GET_META_COUNT] = new StructBase.FieldInfo("successGetMetaCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_GET_META_COUNT] = new StructBase.FieldInfo(
+              "successGetMetaCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_CREATE_LINK_COUNT] = new StructBase.FieldInfo("totalCreateLinkCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_CREATE_LINK_COUNT] = new StructBase.FieldInfo(
+              "totalCreateLinkCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_CREATE_LINK_COUNT] = new StructBase.FieldInfo("successCreateLinkCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_CREATE_LINK_COUNT] = new StructBase.FieldInfo(
+              "successCreateLinkCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_DELETE_LINK_COUNT] = new StructBase.FieldInfo("totalDeleteLinkCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_DELETE_LINK_COUNT] = new StructBase.FieldInfo(
+              "totalDeleteLinkCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_DELETE_LINK_COUNT] = new StructBase.FieldInfo("successDeleteLinkCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_DELETE_LINK_COUNT] = new StructBase.FieldInfo(
+              "successDeleteLinkCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_UPLOAD_BYTES] = new StructBase.FieldInfo("totalUploadBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_UPLOAD_BYTES] = new StructBase.FieldInfo(
+              "totalUploadBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_UPLOAD_BYTES] = new StructBase.FieldInfo("successUploadBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_UPLOAD_BYTES] = new StructBase.FieldInfo(
+              "successUploadBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_APPEND_BYTES] = new StructBase.FieldInfo("totalAppendBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_APPEND_BYTES] = new StructBase.FieldInfo(
+              "totalAppendBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_APPEND_BYTES] = new StructBase.FieldInfo("successAppendBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_APPEND_BYTES] = new StructBase.FieldInfo(
+              "successAppendBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_MODIFY_BYTES] = new StructBase.FieldInfo("totalModifyBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_MODIFY_BYTES] = new StructBase.FieldInfo(
+              "totalModifyBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_MODIFY_BYTES] = new StructBase.FieldInfo("successModifyBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_MODIFY_BYTES] = new StructBase.FieldInfo(
+              "successModifyBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_DOWNLOAD_BYTES] = new StructBase.FieldInfo("totalDownloadloadBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_DOWNLOAD_BYTES] = new StructBase.FieldInfo(
+              "totalDownloadloadBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_DOWNLOAD_BYTES] = new StructBase.FieldInfo("successDownloadloadBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_DOWNLOAD_BYTES] = new StructBase.FieldInfo(
+              "successDownloadloadBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_SYNC_IN_BYTES] = new StructBase.FieldInfo("totalSyncInBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_SYNC_IN_BYTES] = new StructBase.FieldInfo(
+              "totalSyncInBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_SYNC_IN_BYTES] = new StructBase.FieldInfo("successSyncInBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_SYNC_IN_BYTES] = new StructBase.FieldInfo(
+              "successSyncInBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_SYNC_OUT_BYTES] = new StructBase.FieldInfo("totalSyncOutBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_SYNC_OUT_BYTES] = new StructBase.FieldInfo(
+              "totalSyncOutBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_SYNC_OUT_BYTES] = new StructBase.FieldInfo("successSyncOutBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_SYNC_OUT_BYTES] = new StructBase.FieldInfo(
+              "successSyncOutBytes", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_FILE_OPEN_COUNT] = new StructBase.FieldInfo("totalFileOpenCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_FILE_OPEN_COUNT] = new StructBase.FieldInfo(
+              "totalFileOpenCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_FILE_OPEN_COUNT] = new StructBase.FieldInfo("successFileOpenCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_FILE_OPEN_COUNT] = new StructBase.FieldInfo(
+              "successFileOpenCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_FILE_READ_COUNT] = new StructBase.FieldInfo("totalFileReadCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_FILE_READ_COUNT] = new StructBase.FieldInfo(
+              "totalFileReadCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_FILE_READ_COUNT] = new StructBase.FieldInfo("successFileReadCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_FILE_READ_COUNT] = new StructBase.FieldInfo(
+              "successFileReadCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_TOTAL_FILE_WRITE_COUNT] = new StructBase.FieldInfo("totalFileWriteCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_TOTAL_FILE_WRITE_COUNT] = new StructBase.FieldInfo(
+              "totalFileWriteCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_SUCCESS_FILE_WRITE_COUNT] = new StructBase.FieldInfo("successFileWriteCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_SUCCESS_FILE_WRITE_COUNT] = new StructBase.FieldInfo(
+              "successFileWriteCount", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_LAST_SOURCE_UPDATE] = new StructBase.FieldInfo("lastSourceUpdate", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_LAST_SOURCE_UPDATE] = new StructBase.FieldInfo(
+              "lastSourceUpdate", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_LAST_SYNC_UPDATE] = new StructBase.FieldInfo("lastSyncUpdate", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_LAST_SYNC_UPDATE] = new StructBase.FieldInfo(
+              "lastSyncUpdate", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_LAST_SYNCED_TIMESTAMP] = new StructBase.FieldInfo("lastSyncedTimestamp", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_LAST_SYNCED_TIMESTAMP] = new StructBase.FieldInfo(
+              "lastSyncedTimestamp", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_LAST_HEART_BEAT_TIME] = new StructBase.FieldInfo("lastHeartBeatTime", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
-    offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+      fieldsArray[FIELD_INDEX_LAST_HEART_BEAT_TIME] = new StructBase.FieldInfo(
+              "lastHeartBeatTime", offset, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
+      offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
 
-    fieldsArray[FIELD_INDEX_IF_TRUNK_FILE] = new StructBase.FieldInfo("ifTrunkServer", offset, 1);
-    offset += 1;
+      fieldsArray[FIELD_INDEX_IF_TRUNK_FILE] = new StructBase.FieldInfo(
+              "ifTrunkServer", offset, 1);
+      offset += 1;
 
-    fieldsTotalSize = offset;
+      return offset;
   }
 
   protected byte status;
+  protected byte readWriteMode;
   protected String id;
   protected String ipAddr;
-  protected String srcIpAddr;
-  protected String domainName; //http domain name
+  protected String srcId;
   protected String version;
-  protected long totalMB; //total disk storage in MB
-  protected long freeMB;  //free disk storage in MB
+  protected long totalMB;     //total disk space in MB
+  protected long freeMB;      //free disk space in MB
+  protected long reservedMB;  //reserved disk space in MB
   protected int uploadPriority;  //upload priority
   protected Date joinTime; //storage join timestamp (create timestamp)
   protected Date upTime;   //storage service started timestamp
   protected int storePathCount;  //store base path count of each storage server
   protected int subdirCountPerPath;
   protected int storagePort;
-  protected int storageHttpPort; //storage http server port
   protected int currentWritePath; //current write path index
   protected int connectionAllocCount;
   protected int connectionCurrentCount;
@@ -340,15 +402,6 @@ public class StructStorageStat extends StructBase {
   protected Date lastHeartBeatTime;
   protected boolean ifTrunkServer;
 
-  /**
-   * get fields total size
-   *
-   * @return fields total size
-   */
-  public static int getFieldsTotalSize() {
-    return fieldsTotalSize;
-  }
-
   /**
    * get storage status
    *
@@ -358,6 +411,15 @@ public class StructStorageStat extends StructBase {
     return this.status;
   }
 
+  /**
+   * get the read write mode
+   *
+   * @return the read write mode
+   */
+  public byte getReadWriteMode() {
+      return this.readWriteMode;
+  }
+
   /**
    * get storage server id
    *
@@ -377,21 +439,12 @@ public class StructStorageStat extends StructBase {
   }
 
   /**
-   * get source storage ip address
+   * get source storage id
    *
-   * @return source storage ip address
+   * @return source storage id
    */
-  public String getSrcIpAddr() {
-    return this.srcIpAddr;
-  }
-
-  /**
-   * get the domain name of the storage server
-   *
-   * @return the domain name of the storage server
-   */
-  public String getDomainName() {
-    return this.domainName;
+  public String getSrcId() {
+    return this.srcId;
   }
 
   /**
@@ -421,6 +474,15 @@ public class StructStorageStat extends StructBase {
     return this.freeMB;
   }
 
+  /**
+   * get reserved disk space in MB
+   *
+   * @return reserved disk space in MB
+   */
+  public long getReservedMB() {
+    return this.reservedMB;
+  }
+
   /**
    * get storage server upload priority
    *
@@ -475,15 +537,6 @@ public class StructStorageStat extends StructBase {
     return this.storagePort;
   }
 
-  /**
-   * get storage server HTTP port
-   *
-   * @return storage server HTTP port
-   */
-  public int getStorageHttpPort() {
-    return this.storageHttpPort;
-  }
-
   /**
    * get current write path index
    *
@@ -913,22 +966,22 @@ public class StructStorageStat extends StructBase {
    * @param bs     byte array
    * @param offset start offset
    */
-  public void setFields(byte[] bs, int offset) {
+  protected void setFields(StructBase.FieldInfo[] fieldsArray, byte[] bs, int offset) {
     this.status = byteValue(bs, offset, fieldsArray[FIELD_INDEX_STATUS]);
+    this.readWriteMode = byteValue(bs, offset, fieldsArray[FIELD_INDEX_RW_MODE]);
     this.id = stringValue(bs, offset, fieldsArray[FIELD_INDEX_ID]);
     this.ipAddr = stringValue(bs, offset, fieldsArray[FIELD_INDEX_IP_ADDR]);
-    this.srcIpAddr = stringValue(bs, offset, fieldsArray[FIELD_INDEX_SRC_IP_ADDR]);
-    this.domainName = stringValue(bs, offset, fieldsArray[FIELD_INDEX_DOMAIN_NAME]);
+    this.srcId = stringValue(bs, offset, fieldsArray[FIELD_INDEX_SRC_ID]);
     this.version = stringValue(bs, offset, fieldsArray[FIELD_INDEX_VERSION]);
     this.totalMB = longValue(bs, offset, fieldsArray[FIELD_INDEX_TOTAL_MB]);
     this.freeMB = longValue(bs, offset, fieldsArray[FIELD_INDEX_FREE_MB]);
+    this.reservedMB = longValue(bs, offset, fieldsArray[FIELD_INDEX_RESERVED_MB]);
     this.uploadPriority = intValue(bs, offset, fieldsArray[FIELD_INDEX_UPLOAD_PRIORITY]);
     this.joinTime = dateValue(bs, offset, fieldsArray[FIELD_INDEX_JOIN_TIME]);
     this.upTime = dateValue(bs, offset, fieldsArray[FIELD_INDEX_UP_TIME]);
     this.storePathCount = intValue(bs, offset, fieldsArray[FIELD_INDEX_STORE_PATH_COUNT]);
     this.subdirCountPerPath = intValue(bs, offset, fieldsArray[FIELD_INDEX_SUBDIR_COUNT_PER_PATH]);
     this.storagePort = intValue(bs, offset, fieldsArray[FIELD_INDEX_STORAGE_PORT]);
-    this.storageHttpPort = intValue(bs, offset, fieldsArray[FIELD_INDEX_STORAGE_HTTP_PORT]);
     this.currentWritePath = intValue(bs, offset, fieldsArray[FIELD_INDEX_CURRENT_WRITE_PATH]);
 
     this.connectionAllocCount = int32Value(bs, offset, fieldsArray[FIELD_INDEX_CONNECTION_ALLOC_COUNT]);
@@ -979,4 +1032,7 @@ public class StructStorageStat extends StructBase {
     this.lastHeartBeatTime = dateValue(bs, offset, fieldsArray[FIELD_INDEX_LAST_HEART_BEAT_TIME]);
     this.ifTrunkServer = booleanValue(bs, offset, fieldsArray[FIELD_INDEX_IF_TRUNK_FILE]);
   }
+
+  public void setFields(byte[] bs, int offset) {
+  }
 }

src/main/java/org/csource/fastdfs/TrackerClient.java

@@ -183,18 +183,30 @@ public class TrackerClient {
             }
 
             ProtoCommon.RecvPackageInfo pkgInfo = ProtoCommon.recvPackage(connection.getInputStream(),
-                    ProtoCommon.TRACKER_PROTO_CMD_RESP,
-                    ProtoCommon.TRACKER_QUERY_STORAGE_STORE_BODY_LEN);
+                    ProtoCommon.TRACKER_PROTO_CMD_RESP, -1);
             this.errno = pkgInfo.errno;
             if (pkgInfo.errno != 0) {
                 return null;
             }
 
-            ip_addr = new String(pkgInfo.body, ProtoCommon.FDFS_GROUP_NAME_MAX_LEN, ProtoCommon.FDFS_IPADDR_SIZE - 1).trim();
+            if (pkgInfo.body.length < ProtoCommon.TRACKER_QUERY_STORAGE_STORE_IPV4_BODY_LEN) {
+                this.errno = ProtoCommon.ERR_NO_EINVAL;
+                throw new IOException("Invalid body length: " + pkgInfo.body.length);
+            }
 
-            port = (int) ProtoCommon.buff2long(pkgInfo.body, ProtoCommon.FDFS_GROUP_NAME_MAX_LEN
-                    + ProtoCommon.FDFS_IPADDR_SIZE - 1);
-            store_path = pkgInfo.body[ProtoCommon.TRACKER_QUERY_STORAGE_STORE_BODY_LEN - 1];
+            int ip_size;
+            if (pkgInfo.body.length == ProtoCommon.TRACKER_QUERY_STORAGE_STORE_IPV6_BODY_LEN) {
+                ip_size = ProtoCommon.FDFS_IPV6_SIZE;
+            } else if (pkgInfo.body.length == ProtoCommon.TRACKER_QUERY_STORAGE_STORE_IPV4_BODY_LEN) {
+                ip_size = ProtoCommon.FDFS_IPV4_SIZE;
+            } else {
+                this.errno = ProtoCommon.ERR_NO_EINVAL;
+                throw new IOException("Invalid body length: " + pkgInfo.body.length);
+            }
+
+            ip_addr = new String(pkgInfo.body, ProtoCommon.FDFS_GROUP_NAME_MAX_LEN, ip_size - 1).trim();
+            port = (int) ProtoCommon.buff2long(pkgInfo.body, ProtoCommon.FDFS_GROUP_NAME_MAX_LEN + ip_size - 1);
+            store_path = pkgInfo.body[pkgInfo.body.length - 1];
 
             return new StorageServer(ip_addr, port, store_path);
         } catch (IOException ex) {
@@ -269,17 +281,26 @@ public class TrackerClient {
                 return null;
             }
 
-            if (pkgInfo.body.length < ProtoCommon.TRACKER_QUERY_STORAGE_STORE_BODY_LEN) {
+            if (pkgInfo.body.length < ProtoCommon.TRACKER_QUERY_STORAGE_STORE_IPV4_BODY_LEN) {
                 this.errno = ProtoCommon.ERR_NO_EINVAL;
-                return null;
+                throw new IOException("Invalid body length: " + pkgInfo.body.length);
             }
 
             int ipPortLen = pkgInfo.body.length - (ProtoCommon.FDFS_GROUP_NAME_MAX_LEN + 1);
-            final int recordLength = ProtoCommon.FDFS_IPADDR_SIZE - 1 + ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
-
-            if (ipPortLen % recordLength != 0) {
-                this.errno = ProtoCommon.ERR_NO_EINVAL;
-                return null;
+            int recordLength = ProtoCommon.FDFS_IPV6_SIZE - 1 + ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+            int ip_size;
+            if ((pkgInfo.body.length >= ProtoCommon.TRACKER_QUERY_STORAGE_STORE_IPV6_BODY_LEN) &&
+                    ipPortLen % recordLength == 0)
+            {
+                ip_size = ProtoCommon.FDFS_IPV6_SIZE;
+            } else {
+                recordLength = ProtoCommon.FDFS_IPV4_SIZE - 1 + ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
+                if (ipPortLen % recordLength  == 0) {
+                    ip_size = ProtoCommon.FDFS_IPV4_SIZE;
+                } else {
+                    this.errno = ProtoCommon.ERR_NO_EINVAL;
+                    throw new IOException("Invalid body length: " + pkgInfo.body.length);
+                }
             }
 
             int serverCount = ipPortLen / recordLength;
@@ -293,8 +314,8 @@ public class TrackerClient {
             int offset = ProtoCommon.FDFS_GROUP_NAME_MAX_LEN;
 
             for (int i = 0; i < serverCount; i++) {
-                ip_addr = new String(pkgInfo.body, offset, ProtoCommon.FDFS_IPADDR_SIZE - 1).trim();
-                offset += ProtoCommon.FDFS_IPADDR_SIZE - 1;
+                ip_addr = new String(pkgInfo.body, offset, ip_size - 1).trim();
+                offset += ip_size - 1;
 
                 port = (int) ProtoCommon.buff2long(pkgInfo.body, offset);
                 offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
@@ -424,18 +445,33 @@ public class TrackerClient {
                 return null;
             }
 
-            if (pkgInfo.body.length < ProtoCommon.TRACKER_QUERY_STORAGE_FETCH_BODY_LEN) {
+            int server_count = 1;
+            int ip_size;
+            if (pkgInfo.body.length < ProtoCommon.TRACKER_QUERY_STORAGE_FETCH_IPV4_BODY_LEN) {
+                this.errno = ProtoCommon.ERR_NO_EINVAL;
                 throw new IOException("Invalid body length: " + pkgInfo.body.length);
             }
 
-            if ((pkgInfo.body.length - ProtoCommon.TRACKER_QUERY_STORAGE_FETCH_BODY_LEN) % (ProtoCommon.FDFS_IPADDR_SIZE - 1) != 0) {
+            if ((pkgInfo.body.length >= ProtoCommon.TRACKER_QUERY_STORAGE_FETCH_IPV6_BODY_LEN) &&
+                    (pkgInfo.body.length - ProtoCommon.TRACKER_QUERY_STORAGE_FETCH_IPV6_BODY_LEN) %
+                    (ProtoCommon.FDFS_IPV6_SIZE - 1) == 0)
+            {
+                ip_size = ProtoCommon.FDFS_IPV6_SIZE;
+                server_count += (pkgInfo.body.length - ProtoCommon.TRACKER_QUERY_STORAGE_FETCH_IPV6_BODY_LEN) /
+                    (ProtoCommon.FDFS_IPV6_SIZE - 1);
+            } else if ((pkgInfo.body.length - ProtoCommon.TRACKER_QUERY_STORAGE_FETCH_IPV4_BODY_LEN) %
+                    (ProtoCommon.FDFS_IPV4_SIZE - 1) == 0)
+            {
+                ip_size = ProtoCommon.FDFS_IPV4_SIZE;
+                server_count += (pkgInfo.body.length - ProtoCommon.TRACKER_QUERY_STORAGE_FETCH_IPV4_BODY_LEN) /
+                    (ProtoCommon.FDFS_IPV4_SIZE - 1);
+            } else {
+                this.errno = ProtoCommon.ERR_NO_EINVAL;
                 throw new IOException("Invalid body length: " + pkgInfo.body.length);
             }
 
-            int server_count = 1 + (pkgInfo.body.length - ProtoCommon.TRACKER_QUERY_STORAGE_FETCH_BODY_LEN) / (ProtoCommon.FDFS_IPADDR_SIZE - 1);
-
-            ip_addr = new String(pkgInfo.body, ProtoCommon.FDFS_GROUP_NAME_MAX_LEN, ProtoCommon.FDFS_IPADDR_SIZE - 1).trim();
-            int offset = ProtoCommon.FDFS_GROUP_NAME_MAX_LEN + ProtoCommon.FDFS_IPADDR_SIZE - 1;
+            ip_addr = new String(pkgInfo.body, ProtoCommon.FDFS_GROUP_NAME_MAX_LEN, ip_size - 1).trim();
+            int offset = ProtoCommon.FDFS_GROUP_NAME_MAX_LEN + ip_size - 1;
 
             port = (int) ProtoCommon.buff2long(pkgInfo.body, offset);
             offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
@@ -443,8 +479,8 @@ public class TrackerClient {
             ServerInfo[] servers = new ServerInfo[server_count];
             servers[0] = new ServerInfo(ip_addr, port);
             for (int i = 1; i < server_count; i++) {
-                servers[i] = new ServerInfo(new String(pkgInfo.body, offset, ProtoCommon.FDFS_IPADDR_SIZE - 1).trim(), port);
-                offset += ProtoCommon.FDFS_IPADDR_SIZE - 1;
+                servers[i] = new ServerInfo(new String(pkgInfo.body, offset, ip_size - 1).trim(), port);
+                offset += ip_size - 1;
             }
 
             return servers;
@@ -568,6 +604,20 @@ public class TrackerClient {
         return this.listStorages(trackerServer, groupName, storageIpAddr);
     }
 
+    private int getIpaddrLength(String ip, byte[] bIpAddr) {
+        if (bIpAddr.length < ProtoCommon.FDFS_IPV4_SIZE) {
+            return bIpAddr.length;
+        } else if (ip.indexOf(':') >= 0) {  //IPv6 address
+            if (bIpAddr.length < ProtoCommon.FDFS_IPV6_SIZE) {
+                return bIpAddr.length;
+            } else {
+                return ProtoCommon.FDFS_IPV6_SIZE - 1;
+            }
+        } else {  //IPv4 address
+            return ProtoCommon.FDFS_IPV4_SIZE - 1;
+        }
+    }
+
     /**
      * query storage server stat info of the group
      *
@@ -576,8 +626,8 @@ public class TrackerClient {
      * @param storageIpAddr the storage server ip address, can be null or empty
      * @return storage server stat array, return null if fail
      */
-    public StructStorageStat[] listStorages(TrackerServer trackerServer,
-                                            String groupName, String storageIpAddr) throws IOException, MyException {
+    public StructStorageStat[] listStorages(TrackerServer trackerServer, String groupName,
+            String storageIpAddr) throws IOException, MyException {
         byte[] header;
         byte[] bGroupName;
         byte[] bs;
@@ -601,17 +651,14 @@ public class TrackerClient {
             byte[] bIpAddr;
             if (storageIpAddr != null && storageIpAddr.length() > 0) {
                 bIpAddr = storageIpAddr.getBytes(ClientGlobal.g_charset);
-                if (bIpAddr.length < ProtoCommon.FDFS_IPADDR_SIZE) {
-                    ipAddrLen = bIpAddr.length;
-                } else {
-                    ipAddrLen = ProtoCommon.FDFS_IPADDR_SIZE - 1;
-                }
+                ipAddrLen = getIpaddrLength(storageIpAddr, bIpAddr);
             } else {
                 bIpAddr = null;
                 ipAddrLen = 0;
             }
 
-            header = ProtoCommon.packHeader(ProtoCommon.TRACKER_PROTO_CMD_SERVER_LIST_STORAGE, ProtoCommon.FDFS_GROUP_NAME_MAX_LEN + ipAddrLen, (byte) 0);
+            header = ProtoCommon.packHeader(ProtoCommon.TRACKER_PROTO_CMD_SERVER_LIST_STORAGE,
+                    ProtoCommon.FDFS_GROUP_NAME_MAX_LEN + ipAddrLen, (byte) 0);
             byte[] wholePkg = new byte[header.length + bGroupName.length + ipAddrLen];
             System.arraycopy(header, 0, wholePkg, 0, header.length);
             System.arraycopy(bGroupName, 0, wholePkg, header.length, bGroupName.length);
@@ -627,8 +674,17 @@ public class TrackerClient {
                 return null;
             }
 
-            ProtoStructDecoder<StructStorageStat> decoder = new ProtoStructDecoder<StructStorageStat>();
-            return decoder.decode(pkgInfo.body, StructStorageStat.class, StructStorageStat.getFieldsTotalSize());
+            if (pkgInfo.body.length % StructIPv6StorageStat.getFieldsTotalSize() == 0) {
+                ProtoStructDecoder<StructIPv6StorageStat> decoder =
+                    new ProtoStructDecoder<StructIPv6StorageStat>();
+                return decoder.decode(pkgInfo.body, StructIPv6StorageStat.class,
+                        StructIPv6StorageStat.getFieldsTotalSize());
+            } else {
+                ProtoStructDecoder<StructIPv4StorageStat> decoder =
+                    new ProtoStructDecoder<StructIPv4StorageStat>();
+                return decoder.decode(pkgInfo.body, StructIPv4StorageStat.class,
+                        StructIPv4StorageStat.getFieldsTotalSize());
+            }
         } catch (IOException ex) {
             try {
                 connection.close();
@@ -683,14 +739,8 @@ public class TrackerClient {
             Arrays.fill(bGroupName, (byte) 0);
             System.arraycopy(bs, 0, bGroupName, 0, len);
 
-            int ipAddrLen;
             byte[] bIpAddr = storageIpAddr.getBytes(ClientGlobal.g_charset);
-            if (bIpAddr.length < ProtoCommon.FDFS_IPADDR_SIZE) {
-                ipAddrLen = bIpAddr.length;
-            } else {
-                ipAddrLen = ProtoCommon.FDFS_IPADDR_SIZE - 1;
-            }
-
+            int ipAddrLen = getIpaddrLength(storageIpAddr, bIpAddr);
             header = ProtoCommon.packHeader(ProtoCommon.TRACKER_PROTO_CMD_SERVER_DELETE_STORAGE, ProtoCommon.FDFS_GROUP_NAME_MAX_LEN + ipAddrLen, (byte) 0);
             byte[] wholePkg = new byte[header.length + bGroupName.length + ipAddrLen];
             System.arraycopy(header, 0, wholePkg, 0, header.length);
@@ -735,8 +785,9 @@ public class TrackerClient {
      * @param storageIpAddr the storage server ip address
      * @return true for success, false for fail
      */
-    public boolean deleteStorage(TrackerGroup trackerGroup,
-                                 String groupName, String storageIpAddr) throws IOException, MyException {
+    public boolean deleteStorage(TrackerGroup trackerGroup, String groupName,
+            String storageIpAddr) throws IOException, MyException
+    {
         int serverIndex;
         int notFoundCount;
         TrackerServer trackerServer;
@@ -805,4 +856,86 @@ public class TrackerClient {
 
         return this.errno == 0;
     }
+
+    /**
+     * query storage server to upload file
+     *
+     * @param trackerServer the tracker server
+     * @param groupName     the group name to upload file to, can be empty
+     * @return storage server object, return null if fail
+     */
+    public StringBuilder fetchStorageIds(boolean haveAllowEmptyField) throws IOException, MyException {
+        byte[] header;
+        int offset = 0;
+        int length;
+        int total_count;
+        int current_count;
+
+        Connection connection = getConnection(null);
+        try {
+            int reqBodyLength;
+            OutputStream out = connection.getOutputStream();
+            StringBuilder builder = new StringBuilder();
+
+            if (haveAllowEmptyField) {
+                reqBodyLength = 5;
+            } else {
+                reqBodyLength = 4;
+            }
+            header = ProtoCommon.packHeader(ProtoCommon.TRACKER_PROTO_CMD_FETCH_STORAGE_IDS, reqBodyLength, (byte)0);
+            byte[] wholePkg = new byte[header.length + reqBodyLength];
+            System.arraycopy(header, 0, wholePkg, 0, header.length);
+            if (haveAllowEmptyField) {
+                wholePkg[wholePkg.length - 1] = 1;
+            }
+            do {
+                byte[] bs = ProtoCommon.int2buff(offset);
+                System.arraycopy(bs, 0, wholePkg, header.length, bs.length);
+                out.write(wholePkg);
+
+                ProtoCommon.RecvPackageInfo pkgInfo = ProtoCommon.recvPackage(
+                        connection.getInputStream(),
+                        ProtoCommon.TRACKER_PROTO_CMD_RESP, -1);
+                this.errno = pkgInfo.errno;
+                if (pkgInfo.errno != 0) {
+                    return null;
+                }
+
+                if (pkgInfo.body.length < 8) {
+                    throw new MyException("invalid body length: " + pkgInfo.body.length);
+                }
+
+                total_count = ProtoCommon.buff2int(pkgInfo.body, 0);
+                current_count = ProtoCommon.buff2int(pkgInfo.body, 4);
+                if (current_count < 0) {
+                    throw new MyException("invalid current count: " + current_count);
+                }
+
+                length = pkgInfo.body.length - 8;
+                if (length == 0) {
+                    break;
+                }
+
+                bs = new byte[length];
+                System.arraycopy(pkgInfo.body, 8, bs, 0, length);
+                builder.append(new String(bs, ClientGlobal.g_charset));
+
+                offset += current_count;
+            } while (offset < total_count);
+
+            return builder;
+        } catch (IOException e) {
+            try {
+                connection.close();
+            } finally {
+                connection = null;
+            }
+            throw e;
+        } finally {
+            if (connection != null) {
+                connection.release();
+            }
+        }
+    }
+
 }

src/main/java/org/csource/fastdfs/TrackerServer.java

@@ -37,15 +37,20 @@ public class TrackerServer {
         this.index = index;
     }
 
-    public Connection getConnection() throws MyException, IOException {
+    protected Connection getConnection(InetSocketAddress sockAddr) throws MyException, IOException {
         Connection connection;
         if (ClientGlobal.g_connection_pool_enabled) {
-            connection = ConnectionPool.getConnection(this.inetSockAddr);
+            connection = ConnectionPool.getConnection(sockAddr);
         } else {
-            connection = ConnectionFactory.create(this.inetSockAddr);
+            connection = ConnectionFactory.create(sockAddr);
         }
         return connection;
     }
+
+    public Connection getConnection() throws MyException, IOException {
+        return this.getConnection(this.inetSockAddr);
+    }
+
     /**
      * get the server info
      *

src/main/resources/fastdfs-client.properties.sample

@@ -9,8 +9,23 @@ fastdfs.http_anti_steal_token = false
 fastdfs.http_secret_key = FastDFS1234567890
 fastdfs.http_tracker_http_port = 80
 
+#tracker_server
+#   IPv4:
+#   for example: 192.168.2.100:22122,122.244.141.46:22122
+#
+#   IPv6:
+#    for example: [2409:8a20:42d:2f40:587a:4c47:72c0:ad8e]:22122
+#
 fastdfs.tracker_servers = 185.245.40.70:22122
 
+
+# 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
+fastdfs.connect_first_by = tracker
+
+
 ## Whether to open the connection pool, if not, create a new connection every time
 fastdfs.connection_pool.enabled = true
 
@@ -21,4 +36,7 @@ fastdfs.connection_pool.max_count_per_entry = 500
 fastdfs.connection_pool.max_idle_time = 3600
 
 ## Maximum waiting time when the maximum number of connections is reached, unit: millisecond, default value is 1000
-fastdfs.connection_pool.max_wait_time_in_ms = 1000
+fastdfs.connection_pool.max_wait_time_in_ms = 1000
+
+## set to false when FastDFS server version <= V6.10
+fastdfs.fetch_storage_ids.have_allow_empty_field = true

src/main/resources/fdfs_client.conf.sample

@@ -5,10 +5,28 @@ http.tracker_http_port = 8080
 http.anti_steal_token = no
 http.secret_key = FastDFS1234567890
 
+#tracker_server
+#   IPv4:
+#   for example: 192.168.2.100,122.244.141.46:22122
+#
+#   IPv6:
+#    for example: [2409:8a20:42d:2f40:587a:4c47:72c0:ad8e]:22122
+#
 tracker_server = 10.0.11.243:22122
 tracker_server = 10.0.11.244:22122
 
+
+# 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
+connect_first_by = tracker
+
+
 connection_pool.enabled = true
 connection_pool.max_count_per_entry = 500
 connection_pool.max_idle_time = 3600
-connection_pool.max_wait_time_in_ms = 1000
+connection_pool.max_wait_time_in_ms = 1000
+
+# set to false when FastDFS server version <= V6.10
+fetch_storage_ids.have_allow_empty_field = true

src/test/java/org/csource/fastdfs/Monitor.java

@@ -14,12 +14,28 @@ import java.text.SimpleDateFormat;
  * load test class
  *
  * @author Happy Fish / YuQing
- * @version Version 1.20
+ * @version Version 1.34
  */
 public class Monitor {
   private Monitor() {
   }
 
+  public static String getReadWriteModeCaption(byte readWriteMode) {
+
+      switch (readWriteMode) {
+          case ProtoCommon.FDFS_RW_MODE_NONE:
+              return "none (disabled)";
+          case ProtoCommon.FDFS_RW_MODE_READONLY:
+              return "readonly";
+          case ProtoCommon.FDFS_RW_MODE_WRITEONLY:
+              return "writeonly";
+          case ProtoCommon.FDFS_RW_MODE_BOTH:
+              return "both (normal)";
+          default:
+              return "unkown";
+      }
+  }
+
   /**
    * entry point
    *
@@ -64,16 +80,23 @@ public class Monitor {
 
       count = 0;
       for (StructGroupStat groupStat : groupStats) {
+        long available_mb;
+        available_mb = groupStat.getFreeMB() - groupStat.getReservedMB();
+        if (available_mb < 0) {
+            available_mb = 0;
+        }
         count++;
         System.out.println("Group " + count + ":");
         System.out.println("group name = " + groupStat.getGroupName());
         System.out.println("disk total space = " + groupStat.getTotalMB() + "MB");
         System.out.println("disk free space = " + groupStat.getFreeMB() + " MB");
+        System.out.println("disk reserved space = " + groupStat.getReservedMB() + " MB");
+        System.out.println("disk availale space = " + available_mb + " MB");
         System.out.println("trunk free space = " + groupStat.getTrunkFreeMB() + " MB");
         System.out.println("storage server count = " + groupStat.getStorageCount());
-        System.out.println("active server count = " + groupStat.getActiveCount());
+        System.out.println("readable server count = " + groupStat.getReadableServerCount());
+        System.out.println("writable server count = " + groupStat.getWritableServerCount());
         System.out.println("storage server port = " + groupStat.getStoragePort());
-        System.out.println("storage HTTP port = " + groupStat.getStorageHttpPort());
         System.out.println("store path count = " + groupStat.getStorePathCount());
         System.out.println("subdir count per path = " + groupStat.getSubdirCountPerPath());
         System.out.println("current write server index = " + groupStat.getCurrentWriteServer());
@@ -90,23 +113,29 @@ public class Monitor {
         SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         int stroageCount = 0;
         for (StructStorageStat storageStat : storageStats) {
+          available_mb = storageStat.getFreeMB() - storageStat.getReservedMB();
+          if (available_mb < 0) {
+            available_mb = 0;
+          }
           stroageCount++;
           System.out.println("\tStorage " + stroageCount + ":");
           System.out.println("\t\tstorage id = " + storageStat.getId());
-          System.out.println("\t\tip_addr = " + storageStat.getIpAddr() + "  " + ProtoCommon.getStorageStatusCaption(storageStat.getStatus()));
-          System.out.println("\t\thttp domain = " + storageStat.getDomainName());
+          System.out.println("\t\tip_addr = " + storageStat.getIpAddr() + "  " +
+                  ProtoCommon.getStorageStatusCaption(storageStat.getStatus()));
+          System.out.println("\t\tread write mode = " + getReadWriteModeCaption(storageStat.getReadWriteMode()));
           System.out.println("\t\tversion = " + storageStat.getVersion());
           System.out.println("\t\tjoin time = " + df.format(storageStat.getJoinTime()));
           System.out.println("\t\tup time = " + (storageStat.getUpTime().getTime() == 0 ? "" : df.format(storageStat.getUpTime())));
-          System.out.println("\t\ttotal storage = " + storageStat.getTotalMB() + "MB");
-          System.out.println("\t\tfree storage = " + storageStat.getFreeMB() + "MB");
+          System.out.println("\t\tdisk total space = " + storageStat.getTotalMB() + "MB");
+          System.out.println("\t\tdisk free space = " + storageStat.getFreeMB() + "MB");
+          System.out.println("\t\tdisk reserved space = " + storageStat.getReservedMB() + " MB");
+          System.out.println("\t\tdisk availale space = " + available_mb + " MB");
           System.out.println("\t\tupload priority = " + storageStat.getUploadPriority());
           System.out.println("\t\tstore_path_count = " + storageStat.getStorePathCount());
           System.out.println("\t\tsubdir_count_per_path = " + storageStat.getSubdirCountPerPath());
           System.out.println("\t\tstorage_port = " + storageStat.getStoragePort());
-          System.out.println("\t\tstorage_http_port = " + storageStat.getStorageHttpPort());
           System.out.println("\t\tcurrent_write_path = " + storageStat.getCurrentWritePath());
-          System.out.println("\t\tsource ip_addr = " + storageStat.getSrcIpAddr());
+          System.out.println("\t\tsource ip_id = " + storageStat.getSrcId());
           System.out.println("\t\tif_trunk_server = " + storageStat.isTrunkServer());
           System.out.println("\t\tconntion.alloc_count  = " + storageStat.getConnectionAllocCount());
           System.out.println("\t\tconntion.current_count  = " + storageStat.getConnectionCurrentCount());

src/test/java/org/csource/fastdfs/Test1.java

@@ -35,7 +35,7 @@ public class Test1 {
             System.out.println("network_timeout=" + ClientGlobal.g_network_timeout + "ms");
             System.out.println("charset=" + ClientGlobal.g_charset);
 
-            TrackerGroup tg = new TrackerGroup(new InetSocketAddress[]{new InetSocketAddress("47.95.221.159", 22122)});
+            TrackerGroup tg = new TrackerGroup(new InetSocketAddress[]{new InetSocketAddress("192.168.3.202", 22122)});
             TrackerClient tc = new TrackerClient(tg);
 
             TrackerServer ts = tc.getTrackerServer();