KLALB 3.6.0开发一半的状态

KLALB V3.6.0 写了一半
2026-07-06 17:16:33 +08:00 · 2026-07-06 17:03:27 +08:00 · 2026-02-27 08:32:03 +08:00 · 2025-11-15 11:19:43 +08:00 · 2025-11-15 11:08:16 +08:00 · 2025-08-08 17:13:27 +08:00
392 changed files with 38741 additions and 4473 deletions
@@ -1,14 +1,33 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
 	<classpathentry kind="src" path="src"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/KNElib"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/jdk-19">
+	<classpathentry kind="lib" path="lib/gson-2.1.jar"/>
+	<classpathentry kind="lib" path="lib/javassist.jar" sourcepath="C:/Users/ADMINI~1/AppData/Local/Temp/1/.org.sf.feeling.decompiler1686963856070/source/javassist-3.29.2-GA-sources.jar"/>
+	<classpathentry kind="lib" path="lib/ini4j.jar"/>
+	<classpathentry kind="lib" path="lib/JFreeChart1.5.2.jar"/>
+	<classpathentry kind="lib" path="lib/toml4j-0.7.1.jar"/>
+	<classpathentry kind="lib" path="lib/pcap4j-core-1.8.2.jar" sourcepath="C:/Users/ADMINI~1/AppData/Local/Temp/1/.org.sf.feeling.decompiler1725520274095/source/pcap4j-core-1.8.2-sources.jar"/>
+	<classpathentry kind="lib" path="lib/pcap4j-packetfactory-propertiesbased-1.8.2.jar"/>
+	<classpathentry kind="lib" path="lib/pcap4j-packetfactory-static-1.8.2.jar"/>
+	<classpathentry kind="lib" path="lib/pcap4j-sample-1.8.2.jar"/>
+	<classpathentry kind="lib" path="lib/slf4j-api-2.0.9.jar"/>
+	<classpathentry kind="lib" path="lib/slf4j-api-2.0.9-javadoc.jar"/>
+	<classpathentry kind="lib" path="lib/slf4j-api-2.0.9-sources.jar"/>
+	<classpathentry kind="lib" path="lib/slf4j-api-2.0.9-tests.jar"/>
+	<classpathentry kind="lib" path="lib/disruptor-4.0.0.jar" sourcepath="lib/disruptor-4.0.0-sources.jar"/>
+	<classpathentry kind="lib" path="lib/disruptor-4.0.0-javadoc.jar"/>
+	<classpathentry kind="lib" path="lib/disruptor-4.0.0-sources.jar"/>
+	<classpathentry kind="lib" path="lib/KNElib1.0.jar"/>
+	<classpathentry kind="lib" path="lib/KNEOptimize.jar"/>
+	<classpathentry kind="lib" path="lib/JavaTUN0.3.jar"/>
+	<classpathentry kind="lib" path="lib/uuid-creator-6.1.1.jar"/>
+	<classpathentry kind="lib" path="lib/jctools-core-4.0.6.jar"/>
+	<classpathentry kind="lib" path="lib/jctools-core-4.0.6-javadoc.jar"/>
+	<classpathentry kind="lib" path="lib/jctools-core-4.0.6-sources.jar"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/jdk-26.0.1">
 		<attributes>
 			<attribute name="module" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="lib" path="lib/gson-2.1.jar"/>
-	<classpathentry kind="lib" path="lib/javassist.jar" sourcepath="C:/Users/ADMINI~1/AppData/Local/Temp/1/.org.sf.feeling.decompiler1686963856070/source/javassist-3.29.2-GA-sources.jar"/>
-	<classpathentry kind="lib" path="lib/ini4j.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
@@ -0,0 +1,10 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Ignored default folder with query files
+/queries/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2">
+    <output url="file://$PROJECT_DIR$/classes" />
+  </component>
+</project>
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/KLALB.iml" filepath="$PROJECT_DIR$/KLALB.iml" />
+    </modules>
+  </component>
+</project>
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>
@@ -0,0 +1,253 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="EclipseModuleManager">
+    <libelement value="jar://$MODULE_DIR$/lib/gson-2.1.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/javassist.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/ini4j.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/JFreeChart1.5.2.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/toml4j-0.7.1.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/pcap4j-core-1.8.2.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/pcap4j-packetfactory-propertiesbased-1.8.2.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/pcap4j-packetfactory-static-1.8.2.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/pcap4j-sample-1.8.2.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/slf4j-api-2.0.9.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/slf4j-api-2.0.9-javadoc.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/slf4j-api-2.0.9-sources.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/slf4j-api-2.0.9-tests.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/disruptor-4.0.0.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/disruptor-4.0.0-javadoc.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/disruptor-4.0.0-sources.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/KNElib1.0.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/KNEOptimize.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/JavaTUN0.3.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/uuid-creator-6.1.1.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/jctools-core-4.0.6.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/jctools-core-4.0.6-javadoc.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/jctools-core-4.0.6-sources.jar!/" />
+    <src_description expected_position="0">
+      <src_folder value="file://$MODULE_DIR$/src" expected_position="0" />
+    </src_description>
+  </component>
+  <component name="NewModuleRootManager">
+    <output url="file://$MODULE_DIR$/bin" />
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module-library">
+      <library name="gson-2.1.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/gson-2.1.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="javassist.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/javassist.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES>
+          <root url="file://$MODULE_DIR$/../../../../Users/ADMINI~1/AppData/Local/Temp/1/.org.sf.feeling.decompiler1686963856070/source/javassist-3.29.2-GA-sources.jar" />
+        </SOURCES>
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="ini4j.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/ini4j.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="JFreeChart1.5.2.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/JFreeChart1.5.2.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="toml4j-0.7.1.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/toml4j-0.7.1.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="pcap4j-core-1.8.2.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/pcap4j-core-1.8.2.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES>
+          <root url="file://$MODULE_DIR$/../../../../Users/ADMINI~1/AppData/Local/Temp/1/.org.sf.feeling.decompiler1725520274095/source/pcap4j-core-1.8.2-sources.jar" />
+        </SOURCES>
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="pcap4j-packetfactory-propertiesbased-1.8.2.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/pcap4j-packetfactory-propertiesbased-1.8.2.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="pcap4j-packetfactory-static-1.8.2.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/pcap4j-packetfactory-static-1.8.2.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="pcap4j-sample-1.8.2.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/pcap4j-sample-1.8.2.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="slf4j-api-2.0.9.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/slf4j-api-2.0.9.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="slf4j-api-2.0.9-javadoc.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/slf4j-api-2.0.9-javadoc.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="slf4j-api-2.0.9-sources.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/slf4j-api-2.0.9-sources.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="slf4j-api-2.0.9-tests.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/slf4j-api-2.0.9-tests.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="disruptor-4.0.0.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/disruptor-4.0.0.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES>
+          <root url="jar://$MODULE_DIR$/lib/disruptor-4.0.0-sources.jar!/" />
+        </SOURCES>
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="disruptor-4.0.0-javadoc.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/disruptor-4.0.0-javadoc.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="disruptor-4.0.0-sources.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/disruptor-4.0.0-sources.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="KNElib1.0.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/KNElib1.0.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="KNEOptimize.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/KNEOptimize.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="JavaTUN0.3.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/JavaTUN0.3.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="uuid-creator-6.1.1.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/uuid-creator-6.1.1.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="jctools-core-4.0.6.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/jctools-core-4.0.6.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="jctools-core-4.0.6-javadoc.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/jctools-core-4.0.6-javadoc.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="jctools-core-4.0.6-sources.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/jctools-core-4.0.6-sources.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="jdk" jdkName="jdk-26.0.1" jdkType="JavaSDK" />
+  </component>
+</module>
@@ -0,0 +1,123 @@
+[
+  {
+    "language": "ZH_CN",
+    "nogui": false,
+    "VirtualAddress": "2486:1:0:0:0:0:0:8888",
+    "VirtualASN": 2142606939373348329,
+    "DNS": [
+      "2486:1:0:0:0:0:0:8888"
+    ],
+    "TCPListen": "0.0.0.0:4565",
+    "UDPListen": "{UDP}0.0.0.0:4572",
+    "VirtualSocketName": "KLALB_Stream",
+    "LineTable": [
+      "07f4acdef99b.ofalias.net:4565"
+    ],
+    "ConnectLineTable": [
+      "home-ipv6.sliveridc1.cn:4565",
+      "home-ltipv6.sliveridc1.cn:4565",
+      "cn-gd-gz.sliveridc1.cn:4565"
+    ],
+    "ntpServerTable": [
+      "{UDP}ntp1.aliyun.com:123",
+      "{UDP}ntp2.aliyun.com:123",
+      "{UDP}ntp3.aliyun.com:123",
+      "{UDP}ntp4.aliyun.com:123",
+      "{UDP}ntp5.aliyun.com:123",
+      "{UDP}ntp6.aliyun.com:123",
+      "{UDP}ntp7.aliyun.com:123",
+      "{UDP}ntp1.tencent.com:123",
+      "{UDP}ntp2.tencent.com:123",
+      "{UDP}ntp3.tencent.com:123",
+      "{UDP}ntp4.tencent.com:123",
+      "{UDP}ntp5.tencent.com:123",
+      "{UDP}time.google.com:123",
+      "{UDP}time.apple.com:123",
+      "{UDP}pool.ntp.org:123",
+      "{UDP}ntp.ntsc.ac.cn:123",
+      "{UDP}us.ntp.org.cn:123"
+    ],
+    "denyLineTableQuery": true,
+    "denyLineTableBroadcast": true,
+    "congestionAlgorithm": "BBR",
+    "burstLimit": 1.5,
+    "delayUpperBound": 1.3,
+    "delayLowerBound": 1.3,
+    "nagleDelayTime": 1000000,
+    "linkNagleDelayTime": 0,
+    "linkConnectionsCount": 1,
+    "TUNName": "KLALB_SRv6",
+    "NetworkInterfaceExcepts": [],
+    "Type": "KLALBController"
+  },
+  {
+    "Listen": "0.0.0.0:4572",
+    "Bridge": {
+      "KLALB": "SocketBridge",
+      "RDP": "SocketBridge",
+      "HTTP": "SocketBridge",
+      "HTTPS": "SocketBridge",
+      "DEFAULT": "MinecraftSocketBridge23332"
+    },
+    "Connect": {
+      "KLALB": "127.0.0.1:4565",
+      "RDP": "127.0.0.1:3389",
+      "HTTP": "127.0.0.1:5212",
+      "HTTPS": "192.168.1.235:443",
+      "DEFAULT": "127.0.0.1:36555"
+    },
+    "Type": "SocketBridge"
+  },
+  {
+    "Listen": "{KLALB_Stream}[::0]:23332",
+    "Bridge": {
+      "DEFAULT": "MinecraftSocketBridge23332"
+    },
+    "Connect": {
+      "DEFAULT": "127.0.0.1:36555"
+    },
+    "Type": "SocketBridge"
+  },
+  {
+    "Listen": "{KLALB_Stream}[::0]:23333",
+    "Bridge": {
+      "DEFAULT": "SocketBridge"
+    },
+    "Connect": {
+      "DEFAULT": "127.0.0.1:5212"
+    },
+    "Type": "SocketBridge"
+  },
+  {
+    "Listen": "{KLALB_Stream}[::0]:25565",
+    "Bridge": {
+      "DEFAULT": "SocketBridge"
+    },
+    "Connect": {
+      "DEFAULT": "127.0.0.1:25566"
+    },
+    "Type": "SocketBridge"
+  },
+  {
+    "Listen": "0.0.0.0:25561",
+    "Bridge": {
+      "KLALB": "SocketBridge",
+      "DEFAULT": "MinecraftSocketBridge23330"
+    },
+    "Connect": {
+      "KLALB": "127.0.0.1:4565",
+      "DEFAULT": "127.0.0.1:25562"
+    },
+    "Type": "SocketBridge"
+  },
+  {
+    "Listen": "{KLALB_Stream}[::0]:23330",
+    "Bridge": {
+      "DEFAULT": "MinecraftSocketBridge23330"
+    },
+    "Connect": {
+      "DEFAULT": "127.0.0.1:25562"
+    },
+    "Type": "SocketBridge"
+  }
+]
@@ -1,3 +0,0 @@
-#Tue Jul 25 19:03:09 CST 2023
-local=0.0.0.0\:35000
-server=127.0.0.1\:4569
@@ -0,0 +1,79 @@
+[ 
+  {"Type":"KLALBController" ,
+    "TCPListen" : "0.0.0.0:4565",
+    "UDPListen" : "{UDP}0.0.0.0:4572",
+    "VirtualSocketName" : "KLALB_Stream",
+    "LineTable":["43.248.189.107:65529",
+"cn-bj-bgp-3.openfrp.top:65529",
+"180.76.147.250:65529",
+"cn-ah-dx-1.natfrp.cloud:65529",
+"cn-nn-dx-1.natfrp.cloud:65529",
+"cn-wh-dx-1.natfrp.cloud:65529",
+"cn-zz-bgp-10.natfrp.cloud:23330",
+"cn-zz-bgp-7.natfrp.cloud:33336",
+"43.143.109.64:49965",
+"frp.104300.xyz:49965",
+"us.afrps.cn:49966",
+"hk.afrps.cn:49966",
+"la.afrps.cn:49966",
+"frp.freefrp.net:49965",
+"frp1.freefrp.net:49965",
+"frp2.freefrp.net:49965",
+"frp4.freefrp.net:49965",
+"cn-he-plc-2.openfrp.top:4572",
+"{UDP}cn-he-plc-2.openfrp.top:4572",
+"frp-mom.top:22226",
+"frp-man.top:36555",
+"us-sjc-bgp-2.openfrp.top:36555",
+"us-sjc-bgp-1.openfrp.top:36555",
+"[240e:340:d856:b700:6d02:6a6a:f9fc:865b]:4572"]
+  },
+ {"Type":"SocketBridge" ,
+    "Listen" : "0.0.0.0:4572",
+"Bridge":{
+      "KLALB" : "SocketBridge",
+      "RDP":"SocketBridge",
+      "HTTP":"SocketBridge",
+      "HTTPS":"SocketBridge",
+      "DEFAULT":"MinecraftSocketBridge23332"
+    } ,
+    "Connect" : {
+      "KLALB" : "127.0.0.1:4565",
+      "RDP":"127.0.0.1:3389",
+      "HTTP":"127.0.0.1:5212",
+      "HTTPS":"192.168.1.235:443",
+      "DEFAULT":"127.0.0.1:36555"
+    }
+  },
+   {"Type":"SocketBridge" ,
+    "Listen" : "{KLALB_Stream}[::0]:23332",
+"Bridge":"MinecraftSocketBridge23332",
+    "Connect" : "127.0.0.1:36555"
+  },
+  { "Type":"SocketBridge" ,
+    "Listen" : "{KLALB_Stream}[::0]:23333",
+"Bridge":"SocketBridge",
+    "Connect" : "127.0.0.1:5212"
+  },
+
+
+
+
+
+ {"Type":"SocketBridge" ,
+    "Listen" : "0.0.0.0:25561",
+"Bridge":{
+      "KLALB" : "SocketBridge",
+      "DEFAULT":"MinecraftSocketBridge23330"
+    } ,
+    "Connect" : {
+      "KLALB" : "127.0.0.1:4565",
+      "DEFAULT":"127.0.0.1:25562"
+    }
+  },
+   {"Type":"SocketBridge" ,
+    "Listen" : "{KLALB_Stream}[::0]:23330",
+"Bridge":"MinecraftSocketBridge23330",
+    "Connect" : "127.0.0.1:25562"
+  }
+]
@@ -1,3 +0,0 @@
-virtualip=67c:72ce:765e:4db1:a02e:92fa:1959:29eb
-bind=0.0.0.0:4569
-local=127.0.0.1:36555
@@ -1,2 +0,0 @@
-{UDP}192.168.1.233:4569
-{UDP}192.168.0.233:4569
@@ -0,0 +1,107 @@
+srv6acc=SRv6 network accelerator system
+networkgraph=Network graph
+language=Language
+basicsettings=Basic settings
+ipv6addr=IPv6 address
+dnsserver=DNS server
+asnumber=AS number
+tcplistening=TCP listening
+udplistening=UDP listening
+openlinetable=Open line table
+autoconnectlinetable=Auto connect line table
+advancedsettings=Advanced settings
+congresscontrolalgorithm=Congress control algorithm
+savesettings=Save settings
+locate=Locate
+find=Find
+home=Home
+uploadspeed=Upload speed
+downloadspeed=Download speed
+uploadpps=Upload PPS
+downloadpps=Download PPS
+uploaddelay=Upload delay
+downloaddelay=Download delay
+copy=Copy
+onlinedevices=Online devices
+monitor=Monitor
+showofflines=Show offline remotelines
+lineaddressport=Line address:port
+addline=Add line
+reconnectall=Reconnect All
+remotelines=Remote lines
+settings=Settings
+saveconfigsuccess=Save config success
+warning=Warning
+invaildipv6addr=IPv6 address:Invaild Input
+invailddnsserver=DNS server:Invaild Input
+invaildasnumber=AS number:Invaild Input
+invaildtcplisten=TCP listen:Invaild Input
+invaildudplisten=UDP listen:Invaild Input
+invaildopenlinetable=Open line table:Invaild Input
+invaildconnectlinetable=Connect line table:Invaild Input
+invaildntpservertable=NTP server addresses:Invaild Input
+unknown=Unknown
+viewlinemonitor=View line monitor
+copylineaddress=Copy line address
+copyvirtualaddress=Copy virtual address
+tryreconnect=Try reconnect
+forcedisconnect=Force disconnect
+removeline=Remove line
+time=Time
+speermonitor=Speed monitor
+delaymonitor=Delay monitor
+speed=Speed
+delay=Delay
+virtualnetsettings=Virtual network settings
+tunnelnetsettings=Tunnel network settings
+linksettings=Link settings
+klalbperf=KLALB-perf Speedtest
+speedtest=Network speed test
+starttest=Start test
+testreport=Test report
+invaildinput=Invaild input
+stoptest=Stop test
+bandwidth=Bandwidth
+nodeinf=Node information
+selectinterface=Select network interface
+add=Add
+edit=Edit
+remove=Remove
+networkinterfaceexcept=Network interface except
+cancel=Cancel
+ok=Ok
+currenttime=Current time
+timesyncsettings=Time sync settings
+ntpservers=NTP server addresses
+nodeinfo=Node information
+basicinfo=Basic info
+overview=Overview
+timerange=Time range
+error=Error
+securitysettings=Security settings
+delayupperbound=Delay upper bound
+delaylowerbound=Delay lower bound
+denyaddrquery=Deny address query
+denyaddrbroadcast=Deny address broadcast
+random=Random
+transmitnagledelaytime=Transmit nagle delay time
+linknagledelaytime=Link nagle delay time
+linkconnectionscount=Link connections count
+tunname=Virtual network device name
+dashboard=Dashboard
+backplanedelay=Backplane delay
+backplanepps=Backplane PPS
+backplaneecnrate=Backplane ECN rate
+backplanelossrate=Backplane Loss rate
+uisettings=UI settings
+nogui=No GUI mode
+bufferusagemonitor=Buffer usage monitor
+buffer=Buffer
+usedbuffer=Used buffer
+maxbuffer=Max buffer
+queueused=Used queue
+downloadbasedelay=Download Base
+uploadbasedelay=Upload Base
+burstlimit=Burst limit
+performancesettings=Performance settings
+performancestrategy=Performance strategy
@@ -0,0 +1,107 @@
+srv6acc=SRv6 网络加速系统
+networkgraph=网络拓扑图
+language=语言
+basicsettings=基本设置
+ipv6addr=IPv6地址
+dnsserver=DNS服务器
+asnumber=AS号码
+tcplistening=TCP监听端口
+udplistening=UDP监听端口
+openlinetable=开放线路列表
+autoconnectlinetable=自动连接线路列表
+advancedsettings=高级设置
+congresscontrolalgorithm=拥塞控制算法
+savesettings=保存设置
+locate=定位 
+find=查找
+home=本机
+uploadspeed=上传速度
+downloadspeed=下载速度
+uploadpps=上传包转发率
+downloadpps=下载包转发率
+uploaddelay=上传延迟
+downloaddelay=下载延迟
+copy=复制
+onlinedevices=在线设备
+monitor=监视器
+showofflines=显示离线远程链路
+lineaddressport=链路地址:端口
+addline=添加链路
+reconnectall=全部重连
+remotelines=远程链路
+settings=设置
+saveconfigsuccess=保存配置成功
+warning=警告
+invaildipv6addr=IPv6地址:非法输入
+invailddnsserver=DNS服务器:非法输入
+invaildasnumber=AS号码:非法输入
+invaildtcplisten=TCP监听端口:非法输入
+invaildudplisten=UDP监听端口:非法输入
+invaildopenlinetable=开放线路列表:非法输入
+invaildconnectlinetable=自动连接线路列表:非法输入
+invaildntpservertable==NTP授时服务器地址:非法输入
+unknown=未知
+viewlinemonitor=打开链路监视器
+copylineaddress=复制链路地址
+copyvirtualaddress=复制虚拟地址
+tryreconnect=立即尝试重连
+forcedisconnect=强制断开连接
+removeline=强制断开连接并移除
+time=时间
+speermonitor=速度监视器
+delaymonitor=延迟监视器
+speed=速度
+delay=延迟
+virtualnetsettings=虚拟网络设置
+tunnelnetsettings=隧道网络设置
+linksettings=链路设置
+klalbperf=KLALB-perf网速测试
+speedtest=网速测试
+starttest=开始测试
+testreport=测速报告
+invaildinput=非法输入
+stoptest=停止测试
+bandwidth=带宽
+nodeinf=节点信息
+selectinterface=选择网卡
+add=添加
+edit=编辑
+remove=移除
+networkinterfaceexcept=网卡排除列表
+cancel=取消
+ok=确定
+currenttime=当前时间
+timesyncsettings=时钟同步设置
+ntpservers=NTP授时服务器地址
+nodeinfo=节点信息
+basicinfo=基本信息
+overview=概览
+timerange=时间范围
+error=错误
+securitysettings=安全设置
+delayupperbound=网络时延上限
+delaylowerbound=网络时延下限
+denyaddrquery=禁用IP地址查询
+denyaddrbroadcast=禁用IP地址广播
+random=随机
+transmitnagledelaytime=传输粘包等待时间
+linknagledelaytime=链路粘包等待时间
+linkconnectionscount=链路连接数
+tunname=虚拟网卡名称
+dashboard=仪表盘
+backplanedelay=背板处理延迟
+backplanepps=背板包转发率
+backplaneecnrate=背板ECN率
+backplanelossrate=背板丢包率
+uisettings=UI设置
+nogui=无GUI模式
+bufferusagemonitor=缓冲区监视器
+buffer=缓冲区
+usedbuffer=已用缓冲区
+maxbuffer=最大缓冲区
+queueused=已用队列
+downloadbasedelay=下载延迟基线
+uploadbasedelay=上传延迟基线
+burstlimit=突发限制
+performancesettings=性能设置
+performancestrategy=性能策略
@@ -0,0 +1,75 @@
+package org.kne.cloud.clock;
+
+import java.util.concurrent.locks.ReentrantLock;
+
+public class AdjustedNanoClock {
+private ReentrantLock lock=new ReentrantLock();
+	
+	
+	public ReentrantLock getLock() {
+		return lock;
+	}
+
+	
+	private volatile long delta=0;
+	private volatile long accuracy=Long.MAX_VALUE;
+	private boolean unsetted=true;
+	public long getCurrentTime() {
+		return System.nanoTime()+delta;
+	}
+	public AdjustedNanoClock(long delta) {
+		super();
+		this.delta = delta;
+	}
+	public AdjustedNanoClock() {
+	}
+	@Override
+	public String toString() {
+		return "AdjustedNanoClock [delta=" + delta + ", accuracy=" + accuracy + "]";
+	}
+	public long getDelta() {
+		return delta;
+	}
+	public void setDelta(long delta) {
+		this.delta = delta;
+	}
+	public void setCurrentTime(long curr) {
+		delta=curr-System.nanoTime();
+	}
+	public void setCurrentTime2(long curr) {
+		if(unsetted) {
+			unsetted=false;
+			delta=curr-System.nanoTime();
+		}else {
+		delta=(delta*9+ curr-System.nanoTime())/10;
+		}
+	}
+	public long getAccuracy() {
+		return accuracy;
+	}
+	public void calibrate(long delta,long taccurace) {
+		if(accuracy==Long.MAX_VALUE||taccurace<= accuracy) {
+			accuracy=taccurace;
+			unsetted=false;
+			this.delta=delta;
+			//System.out.println(delta+" "+currentTime+" "+taccurace);
+		}else {
+			accuracy=(accuracy*9999+taccurace)/10000;
+		} 
+	}
+	public void calibrate2(long delta,long taccurace) {
+		if(accuracy==Long.MAX_VALUE||taccurace<= accuracy) {
+			accuracy=taccurace;	
+			if(unsetted) {
+				unsetted=false;
+				this.delta=delta;
+			}else {
+				this.delta=(this.delta*9+delta)/10;
+			}
+			//System.out.println(delta+" "+currentTime+" "+taccurace);
+		}else {
+			accuracy=(accuracy*9999+taccurace)/10000;
+		}
+	}
+	
+}
@@ -0,0 +1,31 @@
+package org.kne.cloud.clock;
+
+public class ExponentialBackoffTimeClock {
+
+	private volatile long coolingTime=5000000000L;
+	
+	{
+		resetCoolingTime();
+	}
+	public volatile long minCoolingTime=5000000000L,maxCoolingTime=300000000000L;
+	public ExponentialBackoffTimeClock(long minCoolingTime, long maxCoolingTime) {
+		super();
+		this.minCoolingTime = minCoolingTime;
+		this.maxCoolingTime = maxCoolingTime;
+	}
+	public ExponentialBackoffTimeClock() {
+		super();
+	}
+	public long getCoolingTime() {
+		return coolingTime;
+	}
+	public void incCoolingTime() {
+		coolingTime<<=1;
+		if(coolingTime>maxCoolingTime) {
+			coolingTime=maxCoolingTime;
+		}
+	}
+	public void resetCoolingTime() {
+		coolingTime=minCoolingTime;
+	}
+}
@@ -0,0 +1,258 @@
+package org.kne.cloud.clock;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.locks.ReentrantLock;
+
+import org.kne.math.Long128;
+
+public class HighAccuracyClock {
+	
+	
+    private final long initialCPUNanoTime;
+    private final Long128 initialSystemNanoTime;
+    private volatile long baseCPUNanoTime;
+    private volatile Long128 baseSystemNanoTime;
+    
+    private volatile long frequency=1000000000;//1000015000
+    private volatile long frequency2=frequency*0xffffffffL/1000000000L;
+    
+	private ReentrantLock lock=new ReentrantLock();
+	
+    private static final Long128 NANOS_PER_MILLIS = Long128.valueOf(TimeUnit.MILLISECONDS.toNanos(1));
+    
+
+    private static final Long128 NANOS_PER_SECONDS = Long128.valueOf(TimeUnit.SECONDS.toNanos(1));
+	public static final HighAccuracyClock SYSTEM_CLOCK = new HighAccuracyClock();
+    
+    
+    public HighAccuracyClock() {
+        this.initialSystemNanoTime =Long128.valueOf( System.currentTimeMillis() ).multiply(NANOS_PER_MILLIS);
+        this.initialCPUNanoTime = System.nanoTime();
+        this.baseSystemNanoTime=initialSystemNanoTime;
+        this.baseCPUNanoTime=initialCPUNanoTime;
+    }
+    
+    public long getFrequency() {
+		return frequency;
+	}
+
+	public void setFrequency(long frequency) {
+		lock.lock();
+    	try {
+    		long curr=System.nanoTime();
+    		long nanoela=curr-baseCPUNanoTime;
+    		baseCPUNanoTime=curr;
+    		baseSystemNanoTime=baseSystemNanoTime.add( Long128.valueOf(nanoela).multiply(this.frequency).divide(NANOS_PER_SECONDS));
+		this.frequency = frequency;
+		this.frequency2=frequency*0xffffffffL/1000000000L;
+    	}finally {
+    		lock.unlock();
+    	}
+	}
+	
+	
+	public void adjustFrequency(long fdelta) {
+		lock.lock();
+    	try {
+    		compact();
+		this.frequency = frequency+fdelta;
+		this.frequency2=frequency*0xffffffffL/1000000000L;
+    	}finally {
+    		lock.unlock();
+    	}
+	}
+	
+
+	private void compact() {
+		lock.lock();
+    	try {
+		long curr=System.nanoTime();
+		long nanoela=curr-baseCPUNanoTime;
+		baseCPUNanoTime=curr;
+		baseSystemNanoTime=baseSystemNanoTime.add(Long128.valueOf(nanoela).multiply(this.frequency).divide(NANOS_PER_SECONDS));
+    	}finally {
+    		lock.unlock();
+    	}
+	}
+
+	/**
+     * 获取从1970-01-01开始的当前时间（纳秒精度）
+     */
+    public Long128 getCurrentTimeNanos() {
+    	Long128 mul=Long128.valueOf(System.nanoTime()-baseCPUNanoTime).multiply(frequency2);
+        return mul.shiftRight(32).add(baseSystemNanoTime);
+    }
+    
+    /**
+     * 获取从1970-01-01开始的当前时间（毫秒精度）
+     */
+    public long getCurrentTimeMillis() {
+        return getCurrentTimeNanos().divide(NANOS_PER_MILLIS).longValue();
+    }
+    
+    /**
+     * 获取 NTPv4 128 位时间戳
+     */
+    public Long128 getCurrentTimeNTP128() {
+        return NTPTimestamps.nanosToNtp128BitTimestamp(getCurrentTimeNanos());
+    }
+    
+    /**
+     * 获取 NTPv4 64 位时间戳
+     */
+    public Long128 getCurrentTimeNTP64() {
+        return NTPTimestamps.ntp128To64(getCurrentTimeNTP128());
+    }
+    
+    /**
+     * 获取时钟创建以来经过的时间（纳秒）
+     */
+    public long getElapsedNanos() {
+        return System.nanoTime() - initialCPUNanoTime;
+    }
+    
+    // ================== 修复的时间同步方法 ==================
+    
+    /**
+     * 强制同步到指定时间（正确版本）
+     * @param targetNanos 目标时间（从1970年开始的纳秒数）
+     */
+    public void syncToTime(Long128 targetNanos) {
+    	lock.lock();
+    	try {
+       baseCPUNanoTime= System.nanoTime();
+       baseSystemNanoTime=targetNanos;
+    	}finally {
+    		lock.unlock();
+    	}
+    }
+    
+    /**
+     * 基于参考时钟进行同步（更安全的方法）
+     * @param referenceClock 参考时钟
+     */
+    public void syncToClock(HighAccuracyClock referenceClock) {
+    	syncToClock(referenceClock,BigInteger.ZERO);
+    }
+    
+    
+    /**
+     * 基于参考时钟进行同步（更安全的方法）
+     * @param referenceClock 参考时钟
+     * @param delta 网络延迟（纳秒），可选
+     */
+    public void syncToClock(HighAccuracyClock referenceClock, BigInteger delta) {
+        if (delta == null) {
+            delta = BigInteger.ZERO;
+        }
+        lock.lock();
+    	try {
+        baseCPUNanoTime=System.nanoTime();
+        baseSystemNanoTime=referenceClock.getCurrentTimeNanos();
+    	}finally {
+    		lock.unlock();
+    	}
+    }
+    
+    /**
+     * 基于NTP时间戳同步
+     * @param ntp128Timestamp NTP 128位时间戳
+     */
+    public void syncToNTPTime(Long128 ntp128Timestamp) {
+    	Long128 targetNanos = NTPTimestamps.ntp128BitToNanosTimestamp(ntp128Timestamp);
+        syncToTime(targetNanos);
+    }
+    
+    
+    
+    /**
+     * 调整时钟（用于时间同步）
+     * @param delta 要调整的纳秒数（正数调快，负数调慢）
+     */
+    public void adjustClock(Long128 delta) {
+    	lock.lock();
+    	try {
+        baseSystemNanoTime = baseSystemNanoTime.add(delta);
+    	}finally {
+    		lock.unlock();
+    	}
+    }
+    
+    /**
+     * 调整时钟（用于时间同步）
+     * @param delta 要调整的纳秒数（正数调快，负数调慢）
+     */
+    public void adjustClock(Long128 delta, double adjPercent) {
+        BigInteger adjustment=new BigDecimal(delta.toBigInteger()).multiply(BigDecimal.valueOf( adjPercent)).toBigInteger();
+    	lock.lock();
+    	try {
+    		baseSystemNanoTime = baseSystemNanoTime.add(Long128 .valueOf(adjustment));
+    	}finally {
+    		lock.unlock();
+    	}
+    }
+    
+    
+    
+    /**
+     * 获取时钟偏差（当前时间与真实时间的差异）
+     */
+    public Long128 getClockError(Long128 referenceTime) {
+        return getCurrentTimeNanos().subtract(referenceTime);
+    }
+    
+    /**
+     * 检查时钟是否同步（误差在允许范围内）
+     */
+    public boolean isSynchronized(Long128 referenceTime, Long128 tolerance) {
+    	Long128 error = getClockError(referenceTime).abs();
+        return error.compareTo(tolerance) <= 0;
+    }
+    
+    
+ // ================== toString 方法 ==================
+    
+   
+    
+    /**
+     * 转换为详细格式的字符串（包含纳秒）
+     */
+    public String toString() {
+    	Long128 nanos = getCurrentTimeNanos();
+       return NTPTimestamps.nanosSince1970ToString(nanos);
+    }
+    
+    public String toString2() {
+    	Long128 nanos = getCurrentTimeNanos();
+        return NTPTimestamps.nanosSince1970ToString2(nanos);
+	}
+
+	public long getInitialCPUNanoTime() {
+		return initialCPUNanoTime;
+	}
+
+	public Long128 getInitialSystemNanoTime() {
+		return initialSystemNanoTime;
+	}
+
+	
+    
+    public static void main(String[] args) throws InterruptedException {
+    	HighAccuracyClock hac=new HighAccuracyClock();
+		while(true) {
+			System.out.println(hac.getCurrentTimeNanos());
+			Thread.sleep(1000);
+		}
+	}
+
+	
+    
+   
+}
@@ -0,0 +1,259 @@
+package org.kne.cloud.clock;
+
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+
+import org.kne.math.Long128;
+
+public class NTPTimestamps {
+
+    // 常量定义
+    public static final Long128 NANOS_PER_SECOND = Long128.valueOf(1_000_000_000L);
+    public static final Long128 NANOS_PER_MILLIS = Long128.valueOf(1_000_000L);
+    
+    // NTP 纪元 (1900) 和 Unix 纪元 (1970) 之间的纳秒差
+    public static final Long128 NTP_EPOCH_OFFSET_NS = Long128.valueOf(2208988800L)
+                                                                 .multiply(NANOS_PER_SECOND);
+    
+    // 2^64 值，用于单位转换
+    public static final Long128 TWO_POW_64 = Long128.ONE.shiftLeft(64);
+    
+    // 2^32 值，用于 64 位时间戳处理
+    public static final Long128 TWO_POW_32 = Long128.ONE.shiftLeft(32);
+    
+    // 掩码常量
+    public static final Long128 MASK_32_BIT = new Long128(0xFFFFFFFF);
+    public static final Long128 MASK_64_BIT = new Long128(0xFFFFFFFFFFFFFFFFL);
+
+    // ================== 核心转换方法 ==================
+    // 2^32 秒，约 136.192 年，一个 NTP 纪元的长度
+    public static final Long128 SECONDS_PER_ERA = Long128.valueOf(0x100000000L);
+	private static final Long128 TWO_POW_N64_PER_NANOS = Long128.valueOf("1208925819614629");
+    
+    public static Long128 inferNtp64To128(long remote64Bit,Long128 local128Bit ) {
+    	return inferNtp64To128(toUnsignedLong128(remote64Bit),local128Bit);
+    }
+   
+    
+    /**
+     * 根据本地 128 位时间戳和网络 64 位时间戳，推断并补全纪元信息
+     * 
+     * @param remote64Bit 从网络接收的 64 位 NTP 时间戳
+     * @param local128Bit 本地已知的 128 位 NTP 时间戳
+     * @return 推断出的完整 128 位 NTP 时间戳
+     */
+    public static Long128 inferNtp64To128(Long128 remote64Bit,Long128 local128Bit ) {
+        // 1. 从本地 128 位时间戳中提取纪元号和 64 位时间戳部分
+        Long128 localEra = NTPTimestamps.getEraNumber(local128Bit);
+        Long128 local64Bit = NTPTimestamps.getNtp64Timestamp(local128Bit);
+        
+        // 3. 计算本地和远程 64 位时间戳的差异
+        Long128 difference = remote64Bit.subtract(local64Bit);
+        
+        // 4. 判断纪元关系并推断远程时间戳的纪元
+        Long128 remoteEra;
+        
+        // 如果差异很大（超过半个纪元），可能需要调整纪元
+        Long128 halfEra = Long128.valueOf(Long.MAX_VALUE);
+        
+        if (difference.compareTo(halfEra) > 0) {
+            // 远程时间戳比本地小很多，可能属于上一个纪元
+            remoteEra = localEra.subtract(Long128.ONE);
+        } else if (difference.compareTo(halfEra.negate()) < 0) {
+            // 远程时间戳比本地大很多，可能属于下一个纪元
+            remoteEra = localEra.add(Long128.ONE);
+        } else {
+            // 差异不大，属于同一个纪元
+            remoteEra = localEra;
+        }
+        
+        // 5. 组合纪元号和 64 位时间戳，得到完整的 128 位时间戳
+        return NTPTimestamps.ntp64To128(remote64Bit, remoteEra);
+    }
+    /**
+     * 将从1970年开始的纳秒数转换为 NTPv4 128 位时间戳
+     * 128位时间戳表示从1900年1月1日起经过的 2⁻⁶⁴ 秒的数量
+     */
+    public static Long128 nanosToNtp128BitTimestamp(Long128 nanosSince1970) {
+        // 1. 计算从 1900 年开始的总纳秒数
+        Long128 totalNanosFrom1900 = nanosSince1970.add(NTP_EPOCH_OFFSET_NS);
+
+        // 2. 将纳秒转换为 2⁻⁶⁴ 秒单位
+      //  return totalNanosFrom1900.multiply(TWO_POW_64).divide(NANOS_PER_SECOND);
+        return totalNanosFrom1900.multiply(TWO_POW_N64_PER_NANOS).shiftRight(16);
+    }
+
+    /**
+     * 从 NTPv4 128 位时间戳转换回从1970年开始的纳秒数
+     */
+    public static Long128 ntp128BitToNanosTimestamp(Long128 ntp128Timestamp) {
+        // 1. 将 2⁻⁶⁴ 秒单位转换回纳秒
+        Long128 totalNanosFrom1900 = ntp128Timestamp.multiply(NANOS_PER_SECOND).divide(TWO_POW_64);
+        
+        // 2. 计算从 1970 年开始的总纳秒数
+        return  totalNanosFrom1900.subtract(NTP_EPOCH_OFFSET_NS);
+    }
+
+    
+    public static Long128 nanosToNtp128BitTimeInterval(Long128 nanos) {
+        // 2. 将纳秒转换为 2⁻⁶⁴ 秒单位
+        return nanos.multiply(TWO_POW_64).divide(NANOS_PER_SECOND);
+    }
+
+  
+    public static Long128 ntp128BitToNanosInterval(Long128 ntp128Timestamp) {
+        // 1. 将 2⁻⁶⁴ 秒单位转换回纳秒
+        Long128 totalNanosFrom1900 = ntp128Timestamp.multiply(NANOS_PER_SECOND).divide(TWO_POW_64);
+       
+        return totalNanosFrom1900;
+    }
+    
+    
+    // ================== 128位 ↔ 64位 转换 ==================
+
+    /**
+     * 将 NTP 128 位时间戳转换为 NTP 64 位时间戳
+     * 64位时间戳就是128位时间戳的中间64位
+     */
+    public static Long128 ntp128To64(Long128 ntp128Timestamp) {
+        return ntp128Timestamp.shiftRight(32).and(MASK_64_BIT);
+    }
+
+    /**
+     * 将 NTP 64 位时间戳转换为 NTP 128 位时间戳
+     * 64位时间戳放在128位时间戳的中间64位，高32位Era和低32位分数为0
+     */
+    public static Long128 ntp64To128(Long128 ntp64Timestamp) {
+        return ntp64Timestamp.and(MASK_64_BIT).shiftLeft(32);
+    }
+
+    /**
+     * 将 NTP 64 位时间戳转换为 NTP 128 位时间戳（指定Era Number）
+     */
+    public static Long128 ntp64To128(Long128 ntp64Timestamp, Long128 eraNumber) {
+        return eraNumber.and(MASK_32_BIT).shiftLeft(96)
+               .or(ntp64Timestamp.and(MASK_64_BIT).shiftLeft(32));
+    }
+
+    /**
+     * 从 NTP 128 位时间戳中提取 Era Number（高32位）
+     */
+    public static Long128 getEraNumber(Long128 ntp128Timestamp) {
+        return ntp128Timestamp.shiftRight(96).and(MASK_32_BIT);
+    }
+
+    /**
+     * 从 NTP 128 位时间戳中提取 64 位时间戳（中间64位）
+     */
+    public static Long128 getNtp64Timestamp(Long128 ntp128Timestamp) {
+        return ntp128Timestamp.shiftRight(32).and(MASK_64_BIT);
+    }
+
+    /**
+     * 从 NTP 128 位时间戳中提取分数部分（低32位）
+     */
+    public static Long128 getFraction(Long128 ntp128Timestamp) {
+        return ntp128Timestamp.and(MASK_32_BIT);
+    }
+
+    // ================== 工具方法 ==================
+
+    /**
+     * 从毫秒和纳秒偏移构造 Long128 纳秒
+     */
+    public static Long128 toNanosSince1970(long unixTimeMillis, long nanosOffset) {
+        return Long128.valueOf(unixTimeMillis)
+                        .multiply( NANOS_PER_MILLIS)
+                        .add(Long128.valueOf(nanosOffset));
+    }
+
+    /**
+     * 从 Long128 纳秒提取毫秒和纳秒偏移
+     */
+    public static long[] toMillisAndNanos(Long128 nanosSince1970) {
+    	Long128[] millisAndNanos = nanosSince1970.divideAndRemainder( NANOS_PER_MILLIS);
+        return new long[]{millisAndNanos[0].longValue(), millisAndNanos[1].longValue()};
+    }
+
+    /**
+     * 计算两个 128 位时间戳之间的时间差（纳秒）
+     */
+    public static Long128 calculateTimeDifference(Long128 timestamp1, Long128 timestamp2) {
+        Long128 diff = timestamp2.subtract(timestamp1);
+        return diff.multiply(NANOS_PER_SECOND).divide(TWO_POW_64);
+    }
+
+    
+
+    /**
+     * 将 64 位 NTP 时间戳分解为秒数和分数
+     */
+    public static Long128[] parseNtp64Timestamp(Long128 ntp64Timestamp) {
+        Long128 seconds = ntp64Timestamp.shiftRight(32).and(MASK_32_BIT);
+        Long128 fraction = ntp64Timestamp.and(MASK_32_BIT);
+        return new Long128[]{seconds, fraction};
+    }
+
+    /**
+     * 从秒数和分数构建 64 位 NTP 时间戳
+     */
+    public static Long128 buildNtp64Timestamp(Long128 seconds, Long128 fraction) {
+        return seconds.and(MASK_32_BIT).shiftLeft(32).or(fraction.and(MASK_32_BIT));
+    }
+
+ 
+	
+	 // 日期时间格式化器
+   private static final DateTimeFormatter DEFAULT_FORMATTER = 
+       DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
+   private static final DateTimeFormatter DETAILED_FORMATTER =
+       DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.n");
+	public static String nanosSince1970ToString(Long128 nanos) {
+		 Long128 millis = nanos.divide(Long128.valueOf(1_000_000));
+		 Long128 nanosPart = nanos.mod(Long128.valueOf(1_000_000));
+	        
+	        Instant instant = Instant.ofEpochMilli(millis.longValue());
+	        LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
+	        
+	        return String.format("%s.%06d", 
+	            DEFAULT_FORMATTER.format(dateTime),
+	            nanosPart.longValue());
+	}
+	public static String nanosSince1970ToString2(Long128 nanos) {
+		 Long128 millis = nanos.divide(Long128.valueOf(1_000_000));
+	        
+	        Instant instant = Instant.ofEpochMilli(millis.longValue());
+	        LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
+	        
+	        return DEFAULT_FORMATTER.format(dateTime);
+	}
+	
+	/**
+     * 将 128 位时间戳转换为可读字符串
+     */
+    public static String ntp128ToString(Long128 ntp128Timestamp) {
+    	Long128 nanosSince1970 = ntp128BitToNanosTimestamp(ntp128Timestamp);
+        return nanosSince1970ToString(nanosSince1970);
+    }
+    
+    /**
+     * 将 64 位时间戳转换为可读字符串
+     */
+    public static String ntp64ToString(Long128 ntp64Timestamp) {
+    	Long128 nanosSince1970 = ntp128BitToNanosTimestamp(ntp64To128( ntp64Timestamp));
+        return nanosSince1970ToString(nanosSince1970);
+    }
+    
+    public static Long128 toUnsignedLong128(long unsignedLong) {
+        if (unsignedLong >= 0) {
+            return Long128.valueOf(unsignedLong);
+        } else {
+            // 对于负数，通过添加 2^64 来转换为无符号表示
+            return Long128.valueOf(unsignedLong & 0x7FFFFFFFFFFFFFFFL)
+                            .setBit(63);
+        }
+    }
+}
@@ -0,0 +1,16 @@
+package org.kne.cloud.clock;
+
+public class ReliabilityBackoffTimeClock {
+
+	public volatile long maxCoolingTime=300000000000L;
+	public ReliabilityBackoffTimeClock(long maxCoolingTime) {
+		super();
+		this.maxCoolingTime = maxCoolingTime;
+	}
+	public ReliabilityBackoffTimeClock() {
+		super();
+	}
+	public long getCoolingTime(double reliability) {
+		return (long) ((1.0-reliability)*maxCoolingTime);
+	}
+}
@@ -0,0 +1,19 @@
+package org.kne.cloud.clock;
+
+public class WatchDogTimer {
+	private volatile long feedtime=System.nanoTime();
+	private long timeout;
+	public WatchDogTimer(long timeout) {
+		super();
+		this.timeout = timeout;
+	}
+	
+	public void feed() {
+		feedtime=System.nanoTime();
+	}
+	
+	public boolean isBarking() {
+		return(System.nanoTime()-feedtime)>timeout;
+	}
+	
+}
@@ -0,0 +1,41 @@
+package org.kne.cloud.klalb.uitool;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.font.TextAttribute;
+import java.util.Collections;
+import java.util.Map;
+
+import javax.swing.JButton;
+import javax.swing.JTextField;
+import java.awt.BorderLayout;
+import javax.swing.SwingConstants;
+
+import org.kne.cloud.network.klalb.ui.UIEnv;
+
+public class ButtonSettingItem extends SettingItem {
+	protected JButton button;
+	
+	
+	public JButton getButton() {
+		return button;
+	}
+	public ButtonSettingItem(String text,int w,int h) {
+		this(text,UIEnv.getFont().deriveFont((float) 15.0),w,h);
+	}
+/**
+	 * @wbp.parser.constructor
+	 */
+	public ButtonSettingItem(String text, Font deriveFont,int w,int h) {
+		super(text,deriveFont,w,h);
+		button = new JButton(UIEnv.getRsb().getString("clicktoopen")+">>");
+		button.setHorizontalAlignment(SwingConstants.RIGHT);
+		button.setFont(button.getFont().deriveFont(Map.of(TextAttribute.UNDERLINE, TextAttribute.UNDERLINE_ON)));
+		getPanel().add(button, BorderLayout.EAST);
+		button.setBorder(null);
+		button.setOpaque(false);
+		button.setBackground(new Color(0,0,0,0));
+		label.setForeground(Color.GRAY);
+	}
+
+}
@@ -0,0 +1,37 @@
+package org.kne.cloud.klalb.uitool;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Font;
+
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.SwingConstants;
+
+import org.kne.cloud.klalb.uitool.SettingItem;
+import org.kne.cloud.network.klalb.ui.UIEnv;
+
+public class CheckBoxSettingItem extends SettingItem {
+protected JCheckBox button;
+	
+	
+	public JCheckBox getCheckBox() {
+		return button;
+	}
+	public CheckBoxSettingItem(String text,int w,int h) {
+		this(text,UIEnv.getFont().deriveFont((float) 15.0),w,h);
+	}
+/**
+	 * @wbp.parser.constructor
+	 */
+	public CheckBoxSettingItem(String text, Font deriveFont,int w,int h) {
+		super(text,deriveFont,w,h);
+		button = new JCheckBox();
+		button.setHorizontalAlignment(SwingConstants.RIGHT);
+		getPanel().add(button, BorderLayout.CENTER);
+		button.setBorder(null);
+		button.setOpaque(false);
+		button.setBackground(new Color(0,0,0,0));
+		label.setForeground(Color.GRAY);
+	}
+}
@@ -0,0 +1,33 @@
+package org.kne.cloud.klalb.uitool;
+
+import java.awt.Color;
+import java.awt.Font;
+import javax.swing.JTextField;
+import java.awt.BorderLayout;
+import javax.swing.SwingConstants;
+import org.kne.cloud.network.klalb.ui.UIEnv;
+import javax.swing.JComboBox;
+
+public class ComboSettingItem extends SettingItem {
+	
+	
+	private JComboBox comboBox;
+	public JComboBox getComboBox() {
+		return comboBox;
+	}
+	public ComboSettingItem(String text,int w,int h) {
+		this(text,UIEnv.getFont().deriveFont((float) 15.0),w, h);
+	}
+	/**
+	 * @wbp.parser.constructor
+	 */
+	public ComboSettingItem(String text, Font deriveFont,int w,int h) {
+		super(text,deriveFont,w,h);
+		label.setForeground(Color.GRAY);
+		
+		comboBox = new JComboBox();
+		comboBox.setOpaque(false);
+		getPanel().add(comboBox, BorderLayout.CENTER);
+	}
+
+}
@@ -0,0 +1,86 @@
+package org.kne.cloud.klalb.uitool;
+
+import javax.swing.JDialog;
+import javax.swing.JFrame;
+import java.awt.Dimension;
+import java.awt.TextArea;
+import java.awt.BorderLayout;
+import java.awt.Panel;
+import java.awt.Window;
+import javax.swing.JLabel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+import javax.swing.SwingConstants;
+
+import org.kne.cloud.network.klalb.ui.UIEnv;
+
+import javax.swing.ImageIcon;
+import java.awt.Label;
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.TextField;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.Random;
+
+public class CrashReport extends JDialog{
+	private JLabel name;
+	private TextField type;
+	private JTextArea stack;
+	public CrashReport(Window parent ,boolean modal) {
+		super(parent);
+		setModal(modal);
+		setTitle("错误");
+		setIconImage(UIEnv.getIcon());
+		setSize(500, 400);
+		setLocationRelativeTo(null);
+		stack = new JTextArea();
+		stack.setEditable(false);
+		getContentPane().add(new JScrollPane(stack), BorderLayout.CENTER);
+		
+		Panel panel = new Panel();
+		panel.setPreferredSize(new Dimension(500, 100));
+		getContentPane().add(panel, BorderLayout.NORTH);
+		panel.setLayout(null);
+		
+		JLabel lblNewLabel = new JLabel("");
+		lblNewLabel.setIcon(new ImageIcon(CrashReport.class.getResource("/assets/error.jpg")));
+		lblNewLabel.setHorizontalAlignment(SwingConstants.CENTER);
+		lblNewLabel.setBounds(10, 10, 80, 80);
+		panel.add(lblNewLabel);
+		
+		name = new JLabel("");
+		name.setFont(new Font("宋体", Font.PLAIN, 30));
+		name.setForeground(Color.RED);
+		name.setBounds(96, 10, 378, 33);
+		panel.add(name);
+		
+		type = new TextField();
+		type.setEditable(false);
+		type.setBounds(96, 67, 378, 23);
+		panel.add(type);
+		
+		fny = new JLabel("...?");
+		fny.setFont(new Font("MS Song", Font.PLAIN, 10));
+		getContentPane().add(fny, BorderLayout.SOUTH);
+	}
+	String []s=new String[]{"鎴戜滑鍥㈤槦鍙湁涓�涓▼搴忓憳",
+			"鎯虫洿鏂帮紝娌￠棬",
+			"鎴戜滑鐨勬湇鍔″櫒鐪熺殑鏄笓涓氣�滃埌瀹垛�濅簡",
+			"杩炴帴宸蹭涪澶憋細涓嶅幓鍋氬惎鍔ㄥ櫒灏卞幓濂宠锛屼笉鍘诲コ瑁呭氨鍘诲仛鍚姩鍣�",
+			"鍦熻眴鏈嶅姟鍣ㄥ張鍙戣娊浜�"
+	};
+	private JLabel fny;
+	public void report(Throwable e,String t){
+		e.printStackTrace();
+		name.setText(t);
+		type.setText(e.getClass().getName());
+		StringWriter sw=new StringWriter();
+		PrintWriter pw=new PrintWriter(sw);
+		e.printStackTrace(pw);
+		pw.close();
+		stack.setText(sw.toString());fny.setText(s[new Random().nextInt(s.length)]);
+		setVisible(true);
+		
+	}
+}
@@ -23,7 +23,7 @@
 *
 */

-package org.knemcl.uitool;
+package org.kne.cloud.klalb.uitool;

 import javax.swing.*;
 import javax.swing.plaf.*;
@@ -0,0 +1,159 @@
+package org.kne.cloud.klalb.uitool;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.Image;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.IOException;
+import java.net.NetworkInterface;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+import javax.imageio.ImageIO;
+import javax.swing.ImageIcon;
+import javax.swing.JButton;
+import javax.swing.JList;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+import javax.swing.JTextField;
+import javax.swing.ListModel;
+
+import java.awt.BorderLayout;
+import javax.swing.SwingConstants;
+import org.kne.cloud.network.klalb.ui.UIEnv;
+import java.awt.FlowLayout;
+
+public abstract class ListSettingItem<T> extends SettingItem {
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+
+	protected JList<T> list;
+	
+	private Consumer<T> storeRecall;
+	public JList<T> getList() {
+		return list;
+	}
+	public ListSettingItem(String text,int w,int h,XDefaultListModel<T>lm) {
+		this(text,UIEnv.getFont().deriveFont((float) 15.0),w,h,lm);
+	}
+/**
+	 * @wbp.parser.constructor
+	 */
+	public ListSettingItem(String text, Font deriveFont,int w,int h,XDefaultListModel<T> lm) {
+		super(text,deriveFont,w,h);
+		list = new JList<T>(lm);
+		JScrollPane js=new JScrollPane(list);
+		js.getViewport().setOpaque(false);
+		js.setOpaque(false);
+		js.setBackground(new Color(0,0,0,0));
+		getPanel().add(js, BorderLayout.CENTER);
+		list.setBorder(null);
+		list.setOpaque(false);
+		list.setBackground(new Color(0,0,0,0));
+		label.setForeground(Color.GRAY);
+		
+		Dimension dss=new Dimension(25,25);
+		JButton jbt3x=new JButton();
+		jbt3x.setToolTipText(UIEnv.getRsb().getString("add")); 
+		try {
+			jbt3x.setIcon(new ImageIcon(ImageIO .read(ListSettingItem.class.getResourceAsStream("/assets/add.png")).getScaledInstance(dss.width-2, dss.height-2, Image.SCALE_SMOOTH)));
+		} catch (IOException e) {
+			e.printStackTrace();
+		}catch (IllegalArgumentException e) {
+			e.printStackTrace();
+		}
+		jbt3x.setSize(dss);
+		jbt3x.setPreferredSize(dss);
+		jbt3x.addActionListener(new ActionListener() {
+			
+			@Override
+			public void actionPerformed(ActionEvent e) {
+			List<T> x=createEmpty();
+			if(x!=null&&!x.isEmpty())
+			runEdit(x.get(0));
+			}
+		});
+		JButton jbedit=new JButton();
+		jbedit.setToolTipText(UIEnv.getRsb().getString("edit"));
+		try {
+			jbedit.setIcon(new ImageIcon(ImageIO .read(ListSettingItem.class.getResourceAsStream("/assets/edit-fill.png")).getScaledInstance(dss.width-2, dss.height-2, Image.SCALE_SMOOTH)));
+		} catch (IOException e) {
+			e.printStackTrace();
+		}catch (IllegalArgumentException e) {
+			e.printStackTrace();
+		}
+		jbedit.setSize(dss);
+		jbedit.setPreferredSize(dss);
+		jbedit.addActionListener(new ActionListener() {
+			
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				T val=list.getSelectedValue();
+				if(val!=null)
+				runEdit(val);
+			}
+		});
+		
+		JButton jbt4x=new JButton();
+		jbt4x.setToolTipText(UIEnv.getRsb().getString("remove"));
+		try {
+			jbt4x.setIcon(new ImageIcon(ImageIO .read(ListSettingItem.class.getResourceAsStream("/assets/delete-bin-fill.png")).getScaledInstance(dss.width-2, dss.height-2, Image.SCALE_SMOOTH)));
+		} catch (IOException e) {
+			e.printStackTrace();
+		}catch (IllegalArgumentException e) {
+			e.printStackTrace();
+		}
+		jbt4x.setSize(dss);
+		jbt4x.setPreferredSize(dss);
+		jbt4x.addActionListener(new ActionListener() {
+			
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				int v=list.getSelectedIndex();
+				if(v>=0) {
+				lm.remove(v);
+				if(storeRecall!=null)
+					storeRecall.accept(list.getSelectedValue());
+				}
+			}
+		});
+		JPanel jp=new JPanel();
+		jp.setPreferredSize(new Dimension(30, h));
+		FlowLayout flowLayout = (FlowLayout) jp.getLayout();
+		flowLayout.setAlignment(FlowLayout.TRAILING);
+		jp.setOpaque(false);
+		getPanel().add(jp,BorderLayout.EAST);
+		jp.add(jbt3x);
+		jp.add(jbedit);
+		jp.add(jbt4x);
+	}
+	abstract protected void runEdit(T val) ;
+abstract protected List<T> createEmpty() ;
+public void doAdd(T v) {
+	boolean b=true;
+	for (int i = 0; i < list.getModel().getSize(); i++) {
+		if(list.getModel().getElementAt(i)==v) {
+			b=false;
+				break;
+		}
+	}
+	if(b)
+		((XDefaultListModel<T>) list.getModel()).addElement(v);
+	repaint();
+		if(storeRecall!=null)
+			storeRecall.accept(list.getSelectedValue());
+}
+public Consumer<T> getStoreRecall() {
+	return storeRecall;
+}
+public void setStoreRecall(Consumer<T> storeRecall) {
+	this.storeRecall = storeRecall;
+}
+
+}
@@ -0,0 +1,134 @@
+package org.kne.cloud.klalb.uitool;
+
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.File;
+import java.io.IOException;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import javax.swing.*;
+
+import org.kne.cloud.network.klalb.ui.UIEnv;
+
+public class PathInput extends JDialog {
+	private JTextField textField;
+	private boolean checkfile=true;
+	private boolean isdir=false;
+	protected JFileChooser jfc;
+	private Consumer<File> al;
+	public Consumer<File> getAl() {
+		return al;
+	}
+
+	public void setAl(Consumer<File> al) {
+		this.al = al;
+	}
+
+	public PathInput(Window d){
+		super(d);
+		setResizable(false);
+		setModal(true);
+		setSize(500, 110);
+		setLocationRelativeTo(d);
+
+		setIconImage(UIEnv.getIcon());
+		
+		textField = new JTextField();
+		textField.setPreferredSize(new Dimension(400,80));
+		textField.setFont(new Font("微软雅黑", Font.PLAIN, 12));
+		getContentPane().add(textField, BorderLayout.CENTER);
+		textField.setColumns(10);
+		
+		JPanel panel = new JPanel();
+		getContentPane().add(panel, BorderLayout.SOUTH);
+		
+		JButton btnok = new JButton(UIEnv.getRsb().getString("ok"));
+		UIEnv.defbut(btnok);
+		panel.add(btnok);
+		btnok.addActionListener(new ActionListener() {
+			
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				File x=new File(textField.getText());
+				if(!checkfile){
+					if(isdir){
+						x.mkdirs();
+					}else{
+						try {
+							x.createNewFile();
+						} catch (IOException e1) {
+							e1.printStackTrace();
+						}
+					}
+					al.accept(x);
+					setVisible(false);
+					return;
+				}
+				if(x.exists()){
+				al.accept(x);
+				setVisible(false);
+				}else{
+					JOptionPane.showMessageDialog(PathInput.this, UIEnv.getRsb().getString("filenotexist"), UIEnv.getRsb().getString("error"), JOptionPane.ERROR_MESSAGE);
+				}
+			}
+		});
+		JButton btnNewButton_1 = new JButton(UIEnv.getRsb().getString("browse"));
+		UIEnv.defbut(btnNewButton_1);
+		panel.add(btnNewButton_1);
+		btnNewButton_1.addActionListener(new ActionListener() {
+			
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				if(jfc.showOpenDialog(PathInput.this)==jfc.APPROVE_OPTION){
+					textField.setText(jfc.getSelectedFile().toString());
+				}
+				/*File f=choose.get();
+				if(f!=null){
+					textField.setText(f.toString());
+				}*/
+			}
+		});
+		JButton button = new JButton(UIEnv.getRsb().getString("cancel"));
+		UIEnv.defbut(button);
+		panel.add(button);
+		button.addActionListener(new ActionListener() {
+			
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				setVisible(false);
+			}
+		});
+		
+
+		jfc=new JFileChooser();
+		jfc.setMultiSelectionEnabled(false);
+	}
+
+
+	public JTextField getTextField() {
+		return textField;
+	}
+
+	public JFileChooser getJfc() {
+		return jfc;
+	}
+
+	public boolean isCheckfile() {
+		return checkfile;
+	}
+	public void setCheckfile(boolean checkfile) {
+		this.checkfile = checkfile;
+	}
+	public boolean isIsdir() {
+		return isdir;
+	}
+	public void setIsdir(boolean isdir) {
+		this.isdir = isdir;
+		if(isdir) {
+			jfc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
+		}else {
+			jfc.setFileSelectionMode(JFileChooser.FILES_ONLY);
+		}
+	}
+}
@@ -0,0 +1,38 @@
+package org.kne.cloud.klalb.uitool;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Font;
+
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JRadioButton;
+import javax.swing.SwingConstants;
+
+import org.kne.cloud.klalb.uitool.SettingItem;
+import org.kne.cloud.network.klalb.ui.UIEnv;
+
+public class RadioButtonSettingItem extends SettingItem {
+protected JRadioButton button;
+	
+	
+	public JRadioButton getRadioButton() {
+		return button;
+	}
+	public RadioButtonSettingItem(String text,int w,int h) {
+		this(text,UIEnv.getFont().deriveFont((float) 15.0),w,h);
+	}
+/**
+	 * @wbp.parser.constructor
+	 */
+	public RadioButtonSettingItem(String text, Font deriveFont,int w,int h) {
+		super(text,deriveFont,w,h);
+		button = new JRadioButton();
+		button.setHorizontalAlignment(SwingConstants.RIGHT);
+		getPanel().add(button, BorderLayout.CENTER);
+		button.setBorder(null);
+		button.setOpaque(false);
+		button.setBackground(new Color(0,0,0,0));
+		label.setForeground(Color.GRAY);
+	}
+}
@@ -0,0 +1,52 @@
+package org.kne.cloud.klalb.uitool;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Font;
+import javax.swing.JPanel;
+import javax.swing.JLabel;
+import javax.swing.border.LineBorder;
+
+import org.kne.cloud.network.klalb.ui.UIEnv;
+
+import javax.swing.SwingConstants;
+
+import javax.swing.SpringLayout;
+
+public class SettingItem extends JPanel {
+	protected JLabel label;
+	private JPanel sub;
+	
+	public JLabel getLabel() {
+		return label;
+	}
+	public SettingItem(String text,int w,int h){
+		this(text,UIEnv.getFont().deriveFont(15.0f),w,h);
+	}
+	public JPanel getPanel(){
+		return sub;
+	}
+	/**
+	 * @wbp.parser.constructor
+	 */
+	public SettingItem(String text,Font f,int w,int h){
+		setSize(w, h);
+		setPreferredSize(new Dimension(w, h));
+		setBackground(UIEnv.getHalfTransparentDefaultColor());
+		SpringLayout springLayout = new SpringLayout();
+		setLayout(springLayout);
+		//setOpaque(false);
+		sub = new JPanel();
+		springLayout.putConstraint(SpringLayout.NORTH, sub, 0, SpringLayout.NORTH, this);
+		springLayout.putConstraint(SpringLayout.WEST, sub, 20, SpringLayout.WEST, this);
+		springLayout.putConstraint(SpringLayout.SOUTH, sub, 0, SpringLayout.SOUTH, this);
+		springLayout.putConstraint(SpringLayout.EAST, sub, -20, SpringLayout.EAST, this);
+		sub.setOpaque(false);
+		add(sub);
+		sub.setLayout(new BorderLayout(5, 0));
+		label = new JLabel(text);
+		label.setFont(f);
+		sub.add(label, BorderLayout.WEST);
+	}
+}
@@ -0,0 +1,51 @@
+package org.kne.cloud.klalb.uitool;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.font.TextAttribute;
+import java.util.Map;
+
+import javax.swing.JButton;
+import javax.swing.JLabel;
+import javax.swing.JSlider;
+import javax.swing.JTextField;
+import java.awt.BorderLayout;
+import javax.swing.SwingConstants;
+import org.kne.cloud.network.klalb.ui.UIEnv;
+
+public class SliderSettingItem extends SettingItem {
+	protected JSlider slider;
+	protected JLabel labelx;
+	
+	public JLabel getLabelx() {
+		return labelx;
+	}
+	public JSlider getSlider() {
+		return slider;
+	}
+	public SliderSettingItem(String text,int w,int h) {
+		this(text,UIEnv.getFont().deriveFont((float) 15.0),w,h);
+	}
+	/**
+	 * @wbp.parser.constructor
+	 */
+	public SliderSettingItem(String text, Font deriveFont,int w,int h) {
+		super(text,deriveFont,w,h);
+		BorderLayout borderLayout = (BorderLayout) getPanel().getLayout();
+		slider = new JSlider();
+		getPanel().add(slider, BorderLayout.CENTER);
+		slider.setBorder(null);
+		slider.setOpaque(false);
+		slider.setBackground(new Color(0,0,0,0));
+		label.setForeground(Color.GRAY);
+		
+		labelx = new JLabel();
+		getPanel().add(labelx, BorderLayout.EAST);
+		labelx.setFont(labelx.getFont());
+		labelx.setBorder(null);
+		labelx.setOpaque(false);
+		labelx.setBackground(new Color(0,0,0,0));
+		labelx.setPreferredSize(new Dimension(40, h));
+	}
+}
@@ -0,0 +1,41 @@
+package org.kne.cloud.klalb.uitool;
+
+import java.awt.Color;
+import java.awt.Font;
+import javax.swing.JButton;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+import javax.swing.JTextField;
+import java.awt.BorderLayout;
+import javax.swing.SwingConstants;
+import org.kne.cloud.network.klalb.ui.UIEnv;
+
+public class TextAreaSettingItem extends SettingItem {
+	protected JTextArea textarea;
+	
+	
+	public JTextArea getTextArea() {
+		return textarea;
+	}
+	public TextAreaSettingItem(String text,int w,int h) {
+		this(text,UIEnv.getFont().deriveFont((float) 15.0),w,h);
+	}
+/**
+	 * @wbp.parser.constructor
+	 */
+	public TextAreaSettingItem(String text, Font deriveFont,int w,int h) {
+		super(text,deriveFont,w,h);
+		textarea = new JTextArea();
+		JScrollPane sp=new JScrollPane(textarea);
+		sp.getViewport().setOpaque(false);
+		sp.setOpaque(false);
+		sp.setBackground(new Color(0,0,0,0));
+		getPanel().add(sp, BorderLayout.CENTER);
+		textarea.setBorder(null);
+		textarea.setOpaque(false);
+		textarea.setBackground(new Color(0,0,0,0));
+		//textarea.setBackground(UIEnv.getDefaultcolor());
+		label.setForeground(Color.GRAY);
+	}
+
+}
@@ -0,0 +1,49 @@
+package org.kne.cloud.klalb.uitool;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.font.TextAttribute;
+import java.util.Map;
+
+import javax.swing.JButton;
+import javax.swing.JTextField;
+import java.awt.BorderLayout;
+import javax.swing.SwingConstants;
+import org.kne.cloud.network.klalb.ui.UIEnv;
+
+public class TextButtonSettingItem extends SettingItem {
+	protected JTextField textField;
+	protected JButton button;
+	
+	public JButton getButton() {
+		return button;
+	}
+	public JTextField getTextField() {
+		return textField;
+	}
+	public TextButtonSettingItem(String text,int w,int h) {
+		this(text,UIEnv.getFont().deriveFont((float) 15.0),w,h);
+	}
+	/**
+	 * @wbp.parser.constructor
+	 */
+	public TextButtonSettingItem(String text, Font deriveFont,int w,int h) {
+		super(text,deriveFont,w,h);
+		BorderLayout borderLayout = (BorderLayout) getPanel().getLayout();
+		textField = new JTextField();
+		textField.setHorizontalAlignment(SwingConstants.RIGHT);
+		getPanel().add(textField, BorderLayout.CENTER);
+		textField.setColumns(10);
+		textField.setBorder(null);
+		textField.setOpaque(false);
+		textField.setBackground(new Color(0,0,0,0));
+		label.setForeground(Color.GRAY);
+		
+		button = new JButton();
+		getPanel().add(button, BorderLayout.EAST);
+		button.setFont(button.getFont());
+		//button.setBorder(null);
+		//button.setOpaque(false);
+		button.setBackground(new Color(0,0,0,0));
+	}
+}
@@ -0,0 +1,35 @@
+package org.kne.cloud.klalb.uitool;
+
+import java.awt.Color;
+import java.awt.Font;
+import javax.swing.JTextField;
+import java.awt.BorderLayout;
+import javax.swing.SwingConstants;
+import org.kne.cloud.network.klalb.ui.UIEnv;
+
+public class TextSettingItem extends SettingItem {
+	protected JTextField textField;
+	
+	
+	public JTextField getTextField() {
+		return textField;
+	}
+	public TextSettingItem(String text,int w,int h) {
+		this(text,UIEnv.getFont().deriveFont((float) 15.0),w,h);
+	}
+	/**
+	 * @wbp.parser.constructor
+	 */
+	public TextSettingItem(String text, Font deriveFont,int w,int h) {
+		super(text,deriveFont,w,h);
+		textField = new JTextField();
+		textField.setHorizontalAlignment(SwingConstants.RIGHT);
+		getPanel().add(textField, BorderLayout.CENTER);
+		textField.setColumns(10);
+		textField.setBorder(null);
+		textField.setOpaque(false);
+		textField.setBackground(new Color(0,0,0,0));
+		label.setForeground(Color.GRAY);
+	}
+
+}
@@ -0,0 +1,233 @@
+/*
+ * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package org.kne.cloud.klalb.uitool;
+
+import javax.swing.ListModel;
+import javax.swing.event.*;
+import java.io.Serializable;
+import java.util.EventListener;
+
+/**
+ * The abstract definition for the data model that provides
+ * a <code>List</code> with its contents.
+ * <p>
+ * <strong>Warning:</strong>
+ * Serialized objects of this class will not be compatible with
+ * future Swing releases. The current serialization support is
+ * appropriate for short term storage or RMI between applications running
+ * the same version of Swing.  As of 1.4, support for long term storage
+ * of all JavaBeans
+ * has been added to the <code>java.beans</code> package.
+ * Please see {@link java.beans.XMLEncoder}.
+ *
+ * @param <E> the type of the elements of this model
+ *
+ * @author Hans Muller
+ * @since 1.2
+ */
+@SuppressWarnings("serial") // Same-version serialization only
+public abstract class XAbstractListModel<E> implements ListModel<E>, Serializable
+{
+    /**
+     * The listener list.
+     */
+    protected EventListenerList listenerList = new EventListenerList();
+
+    /**
+     * Constructor for subclasses to call.
+     */
+    protected XAbstractListModel() {}
+
+    /**
+     * Adds a listener to the list that's notified each time a change
+     * to the data model occurs.
+     *
+     * @param l the <code>ListDataListener</code> to be added
+     */
+    public void addListDataListener(ListDataListener l) {
+        listenerList.add(ListDataListener.class, l);
+    }
+
+
+    /**
+     * Removes a listener from the list that's notified each time a
+     * change to the data model occurs.
+     *
+     * @param l the <code>ListDataListener</code> to be removed
+     */
+    public void removeListDataListener(ListDataListener l) {
+        listenerList.remove(ListDataListener.class, l);
+    }
+
+
+    /**
+     * Returns an array of all the list data listeners
+     * registered on this <code>AbstractListModel</code>.
+     *
+     * @return all of this model's <code>ListDataListener</code>s,
+     *         or an empty array if no list data listeners
+     *         are currently registered
+     *
+     * @see #addListDataListener
+     * @see #removeListDataListener
+     *
+     * @since 1.4
+     */
+    public ListDataListener[] getListDataListeners() {
+        return listenerList.getListeners(ListDataListener.class);
+    }
+
+
+    /**
+     * <code>AbstractListModel</code> subclasses must call this method
+     * <b>after</b>
+     * one or more elements of the list change.  The changed elements
+     * are specified by the closed interval index0, index1 -- the endpoints
+     * are included.  Note that
+     * index0 need not be less than or equal to index1.
+     *
+     * @param source the <code>ListModel</code> that changed, typically "this"
+     * @param index0 one end of the new interval
+     * @param index1 the other end of the new interval
+     * @see EventListenerList
+     * @see XDefaultListModel
+     */
+    protected void fireContentsChanged(Object source, int index0, int index1)
+    {
+        Object[] listeners = listenerList.getListenerList();
+        ListDataEvent e = null;
+
+        for (int i = listeners.length - 2; i >= 0; i -= 2) {
+            if (listeners[i] == ListDataListener.class) {
+                if (e == null) {
+                    e = new ListDataEvent(source, ListDataEvent.CONTENTS_CHANGED, index0, index1);
+                }
+                ((ListDataListener)listeners[i+1]).contentsChanged(e);
+            }
+        }
+    }
+
+
+    /**
+     * <code>AbstractListModel</code> subclasses must call this method
+     * <b>after</b>
+     * one or more elements are added to the model.  The new elements
+     * are specified by a closed interval index0, index1 -- the enpoints
+     * are included.  Note that
+     * index0 need not be less than or equal to index1.
+     *
+     * @param source the <code>ListModel</code> that changed, typically "this"
+     * @param index0 one end of the new interval
+     * @param index1 the other end of the new interval
+     * @see EventListenerList
+     * @see XDefaultListModel
+     */
+    protected void fireIntervalAdded(Object source, int index0, int index1)
+    {
+        Object[] listeners = listenerList.getListenerList();
+        ListDataEvent e = null;
+
+        for (int i = listeners.length - 2; i >= 0; i -= 2) {
+            if (listeners[i] == ListDataListener.class) {
+                if (e == null) {
+                    e = new ListDataEvent(source, ListDataEvent.INTERVAL_ADDED, index0, index1);
+                }
+                ((ListDataListener)listeners[i+1]).intervalAdded(e);
+            }
+        }
+    }
+
+
+    /**
+     * <code>AbstractListModel</code> subclasses must call this method
+     * <b>after</b> one or more elements are removed from the model.
+     * <code>index0</code> and <code>index1</code> are the end points
+     * of the interval that's been removed.  Note that <code>index0</code>
+     * need not be less than or equal to <code>index1</code>.
+     *
+     * @param source the <code>ListModel</code> that changed, typically "this"
+     * @param index0 one end of the removed interval,
+     *               including <code>index0</code>
+     * @param index1 the other end of the removed interval,
+     *               including <code>index1</code>
+     * @see EventListenerList
+     * @see XDefaultListModel
+     */
+    protected void fireIntervalRemoved(Object source, int index0, int index1)
+    {
+        Object[] listeners = listenerList.getListenerList();
+        ListDataEvent e = null;
+
+        for (int i = listeners.length - 2; i >= 0; i -= 2) {
+            if (listeners[i] == ListDataListener.class) {
+                if (e == null) {
+                    e = new ListDataEvent(source, ListDataEvent.INTERVAL_REMOVED, index0, index1);
+                }
+                ((ListDataListener)listeners[i+1]).intervalRemoved(e);
+            }
+        }
+    }
+
+    /**
+     * Returns an array of all the objects currently registered as
+     * <code><em>Foo</em>Listener</code>s
+     * upon this model.
+     * <code><em>Foo</em>Listener</code>s
+     * are registered using the <code>add<em>Foo</em>Listener</code> method.
+     * <p>
+     * You can specify the <code>listenerType</code> argument
+     * with a class literal, such as <code><em>Foo</em>Listener.class</code>.
+     * For example, you can query a list model
+     * <code>m</code>
+     * for its list data listeners
+     * with the following code:
+     *
+     * <pre>ListDataListener[] ldls = (ListDataListener[])(m.getListeners(ListDataListener.class));</pre>
+     *
+     * If no such listeners exist,
+     * this method returns an empty array.
+     *
+     * @param <T> the type of {@code EventListener} class being requested
+     * @param listenerType  the type of listeners requested;
+     *          this parameter should specify an interface
+     *          that descends from <code>java.util.EventListener</code>
+     * @return an array of all objects registered as
+     *          <code><em>Foo</em>Listener</code>s
+     *          on this model,
+     *          or an empty array if no such
+     *          listeners have been added
+     * @exception ClassCastException if <code>listenerType</code> doesn't
+     *          specify a class or interface that implements
+     *          <code>java.util.EventListener</code>
+     *
+     * @see #getListDataListeners
+     *
+     * @since 1.3
+     */
+    public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
+        return listenerList.getListeners(listenerType);
+    }
+}
@@ -0,0 +1,46 @@
+package org.kne.cloud.klalb.uitool;
+
+import java.awt.Graphics;
+import javax.swing.Action;
+import javax.swing.Icon;
+import javax.swing.JButton;
+
+public class XButton extends JButton{
+	/**
+	 * 
+	 */
+	public XButton() {
+		super();
+		super.setContentAreaFilled(false);
+	}
+
+	public XButton(Action a) {
+		super(a);
+		super.setContentAreaFilled(false);
+	}
+
+	public XButton(Icon icon) {
+		super(icon);
+		super.setContentAreaFilled(false);
+	}
+
+	public XButton(String text, Icon icon) {
+		super(text, icon);
+		super.setContentAreaFilled(false);
+	}
+
+	public XButton(String text) {
+		super(text);
+		super.setContentAreaFilled(false);
+	}
+	
+
+
+	@Override
+	public void paint(Graphics g) {
+			g.setColor(getBackground());
+			g.fillRoundRect(0, 0, getWidth()-1, getHeight()-1, 20, 20);
+		super.paint(g);
+	}
+	
+}
@@ -0,0 +1,584 @@
+/*
+ * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package org.kne.cloud.klalb.uitool;
+
+import java.util.Vector;
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Collection;
+import java.util.Enumeration;
+
+
+/**
+ * This class loosely implements the {@code java.util.Vector}
+ * API, in that it implements the 1.1.x version of
+ * {@code java.util.Vector}, has no collection class support,
+ * and notifies the {@code ListDataListener}s when changes occur.
+ * Presently it delegates to a {@code Vector},
+ * in a future release it will be a real Collection implementation.
+ * <p>
+ * <strong>Warning:</strong>
+ * Serialized objects of this class will not be compatible with
+ * future Swing releases. The current serialization support is
+ * appropriate for short term storage or RMI between applications running
+ * the same version of Swing.  As of 1.4, support for long term storage
+ * of all JavaBeans
+ * has been added to the {@code java.beans} package.
+ * Please see {@link java.beans.XMLEncoder}.
+ *
+ * @param <E> the type of the elements of this model
+ *
+ * @author Hans Muller
+ * @since 1.2
+ */
+@SuppressWarnings("serial") // Same-version serialization only
+public class XDefaultListModel<E> extends XAbstractListModel<E> implements Externalizable
+{
+    private Vector<E> delegate = new Vector<E>();
+
+    /**
+     * Constructs a {@code DefaultListModel}.
+     */
+    public XDefaultListModel() {}
+
+    /**
+     * Returns the number of components in this list.
+     * <p>
+     * This method is identical to {@code size}, which implements the
+     * {@code List} interface defined in the 1.2 Collections framework.
+     * This method exists in conjunction with {@code setSize} so that
+     * {@code size} is identifiable as a JavaBean property.
+     *
+     * @return  the number of components in this list
+     * @see #size()
+     */
+    public int getSize() {
+        return delegate.size();
+    }
+
+    /**
+     * Returns the component at the specified index.
+     * <blockquote>
+     * <b>Note:</b> Although this method is not deprecated, the preferred
+     *    method to use is {@code get(int)}, which implements the {@code List}
+     *    interface defined in the 1.2 Collections framework.
+     * </blockquote>
+     * @param      index   an index into this list
+     * @return     the component at the specified index
+     * @throws     ArrayIndexOutOfBoundsException  if the {@code index}
+     *             is negative or greater than the current size of this
+     *             list
+     * @see #get(int)
+     */
+    public E getElementAt(int index) {
+        return delegate.elementAt(index);
+    }
+
+    /**
+     * Copies the components of this list into the specified array.
+     * The array must be big enough to hold all the objects in this list,
+     * else an {@code IndexOutOfBoundsException} is thrown.
+     *
+     * @param   anArray   the array into which the components get copied
+     * @see Vector#copyInto(Object[])
+     */
+    public void copyInto(Object[] anArray) {
+        delegate.copyInto(anArray);
+    }
+
+    /**
+     * Trims the capacity of this list to be the list's current size.
+     *
+     * @see Vector#trimToSize()
+     */
+    public void trimToSize() {
+        delegate.trimToSize();
+    }
+
+    /**
+     * Increases the capacity of this list, if necessary, to ensure
+     * that it can hold at least the number of components specified by
+     * the minimum capacity argument.
+     *
+     * @param   minCapacity   the desired minimum capacity
+     * @see Vector#ensureCapacity(int)
+     */
+    public void ensureCapacity(int minCapacity) {
+        delegate.ensureCapacity(minCapacity);
+    }
+
+    /**
+     * Sets the size of this list.
+     *
+     * @param   newSize   the new size of this list
+     * @see Vector#setSize(int)
+     */
+    public void setSize(int newSize) {
+        int oldSize = delegate.size();
+        delegate.setSize(newSize);
+        if (oldSize > newSize) {
+            fireIntervalRemoved(this, newSize, oldSize-1);
+        }
+        else if (oldSize < newSize) {
+            fireIntervalAdded(this, oldSize, newSize-1);
+        }
+    }
+
+    /**
+     * Returns the current capacity of this list.
+     *
+     * @return  the current capacity
+     * @see Vector#capacity()
+     */
+    public int capacity() {
+        return delegate.capacity();
+    }
+
+    /**
+     * Returns the number of components in this list.
+     *
+     * @return  the number of components in this list
+     * @see Vector#size()
+     */
+    public int size() {
+        return delegate.size();
+    }
+
+    /**
+     * Tests whether this list has any components.
+     *
+     * @return  {@code true} if and only if this list has
+     *          no components, that is, its size is zero;
+     *          {@code false} otherwise
+     * @see Vector#isEmpty()
+     */
+    public boolean isEmpty() {
+        return delegate.isEmpty();
+    }
+
+    /**
+     * Returns an enumeration of the components of this list.
+     *
+     * @return  an enumeration of the components of this list
+     * @see Vector#elements()
+     */
+    public Enumeration<E> elements() {
+        return delegate.elements();
+    }
+
+    /**
+     * Tests whether the specified object is a component in this list.
+     *
+     * @param   elem   an object
+     * @return  {@code true} if the specified object
+     *          is the same as a component in this list
+     * @see Vector#contains(Object)
+     */
+    public boolean contains(Object elem) {
+        return delegate.contains(elem);
+    }
+
+    /**
+     * Searches for the first occurrence of {@code elem}.
+     *
+     * @param   elem   an object
+     * @return  the index of the first occurrence of the argument in this
+     *          list; returns {@code -1} if the object is not found
+     * @see Vector#indexOf(Object)
+     */
+    public int indexOf(Object elem) {
+        return delegate.indexOf(elem);
+    }
+
+    /**
+     * Searches for the first occurrence of {@code elem}, beginning
+     * the search at {@code index}.
+     *
+     * @param   elem    the desired component
+     * @param   index   the index from which to begin searching
+     * @return  the index where the first occurrence of {@code elem}
+     *          is found after {@code index}; returns {@code -1}
+     *          if the {@code elem} is not found in the list
+     * @see Vector#indexOf(Object,int)
+     */
+     public int indexOf(Object elem, int index) {
+        return delegate.indexOf(elem, index);
+    }
+
+    /**
+     * Returns the index of the last occurrence of {@code elem}.
+     *
+     * @param   elem   the desired component
+     * @return  the index of the last occurrence of {@code elem}
+     *          in the list; returns {@code elem} if the object is not found
+     * @see Vector#lastIndexOf(Object)
+     */
+    public int lastIndexOf(Object elem) {
+        return delegate.lastIndexOf(elem);
+    }
+
+    /**
+     * Searches backwards for {@code elem}, starting from the
+     * specified index, and returns an index to it.
+     *
+     * @param  elem    the desired component
+     * @param  index   the index to start searching from
+     * @return the index of the last occurrence of the {@code elem}
+     *          in this list at position less than {@code index};
+     *          returns {@code -1} if the object is not found
+     * @see Vector#lastIndexOf(Object,int)
+     */
+    public int lastIndexOf(Object elem, int index) {
+        return delegate.lastIndexOf(elem, index);
+    }
+
+    /**
+     * Returns the component at the specified index.
+     * <blockquote>
+     * <b>Note:</b> Although this method is not deprecated, the preferred
+     *    method to use is {@code get(int)}, which implements the
+     *    {@code List} interface defined in the 1.2 Collections framework.
+     * </blockquote>
+     *
+     * @param      index   an index into this list
+     * @return     the component at the specified index
+     * @throws     ArrayIndexOutOfBoundsException if the index
+     * is negative or not less than the size of the list
+     * @see #get(int)
+     * @see Vector#elementAt(int)
+     */
+    public E elementAt(int index) {
+        return delegate.elementAt(index);
+    }
+
+    /**
+     * Returns the first component of this list.
+     * @return     the first component of this list
+     * @see Vector#firstElement()
+     * @throws java.util.NoSuchElementException if this
+     * vector has no components
+     */
+    public E firstElement() {
+        return delegate.firstElement();
+    }
+
+    /**
+     * Returns the last component of the list.
+     *
+     * @return  the last component of the list
+     * @see Vector#lastElement()
+     * @throws java.util.NoSuchElementException if this vector
+     * has no components
+     */
+    public E lastElement() {
+        return delegate.lastElement();
+    }
+
+    /**
+     * Sets the component at the specified {@code index} of this
+     * list to be the specified element. The previous component at that
+     * position is discarded.
+     * <blockquote>
+     * <b>Note:</b> Although this method is not deprecated, the preferred
+     *    method to use is {@code set(int,Object)}, which implements the
+     *    {@code List} interface defined in the 1.2 Collections framework.
+     * </blockquote>
+     *
+     * @param      element what the component is to be set to
+     * @param      index   the specified index
+     * @throws     ArrayIndexOutOfBoundsException if the index is invalid
+     * @see #set(int,Object)
+     * @see Vector#setElementAt(Object,int)
+     */
+    public void setElementAt(E element, int index) {
+        delegate.setElementAt(element, index);
+        fireContentsChanged(this, index, index);
+    }
+
+    /**
+     * Deletes the component at the specified index.
+     * <blockquote>
+     * <b>Note:</b> Although this method is not deprecated, the preferred
+     *    method to use is {@code remove(int)}, which implements the
+     *    {@code List} interface defined in the 1.2 Collections framework.
+     * </blockquote>
+     *
+     * @param      index   the index of the object to remove
+     * @see #remove(int)
+     * @see Vector#removeElementAt(int)
+     * @throws ArrayIndexOutOfBoundsException if the index is invalid
+     */
+    public void removeElementAt(int index) {
+        delegate.removeElementAt(index);
+        fireIntervalRemoved(this, index, index);
+    }
+
+    /**
+     * Inserts the specified element as a component in this list at the
+     * specified <code>index</code>.
+     * <blockquote>
+     * <b>Note:</b> Although this method is not deprecated, the preferred
+     *    method to use is {@code add(int,Object)}, which implements the
+     *    {@code List} interface defined in the 1.2 Collections framework.
+     * </blockquote>
+     *
+     * @param      element the component to insert
+     * @param      index   where to insert the new component
+     * @exception  ArrayIndexOutOfBoundsException if the index was invalid
+     * @see #add(int,Object)
+     * @see Vector#insertElementAt(Object,int)
+     */
+    public void insertElementAt(E element, int index) {
+        delegate.insertElementAt(element, index);
+        fireIntervalAdded(this, index, index);
+    }
+
+    /**
+     * Adds the specified component to the end of this list.
+     *
+     * @param   element   the component to be added
+     * @see Vector#addElement(Object)
+     */
+    public void addElement(E element) {
+        int index = delegate.size();
+        delegate.addElement(element);
+        fireIntervalAdded(this, index, index);
+    }
+
+    /**
+     * Removes the first (lowest-indexed) occurrence of the argument
+     * from this list.
+     *
+     * @param   obj   the component to be removed
+     * @return  {@code true} if the argument was a component of this
+     *          list; {@code false} otherwise
+     * @see Vector#removeElement(Object)
+     */
+    public boolean removeElement(Object obj) {
+        int index = indexOf(obj);
+        boolean rv = delegate.removeElement(obj);
+        if (index >= 0) {
+            fireIntervalRemoved(this, index, index);
+        }
+        return rv;
+    }
+
+
+    /**
+     * Removes all components from this list and sets its size to zero.
+     * <blockquote>
+     * <b>Note:</b> Although this method is not deprecated, the preferred
+     *    method to use is {@code clear}, which implements the
+     *    {@code List} interface defined in the 1.2 Collections framework.
+     * </blockquote>
+     *
+     * @see #clear()
+     * @see Vector#removeAllElements()
+     */
+    public void removeAllElements() {
+        int index1 = delegate.size()-1;
+        delegate.removeAllElements();
+        if (index1 >= 0) {
+            fireIntervalRemoved(this, 0, index1);
+        }
+    }
+
+
+    /**
+     * Returns a string that displays and identifies this
+     * object's properties.
+     *
+     * @return a String representation of this object
+     */
+   public String toString() {
+        return delegate.toString();
+    }
+
+
+    /* The remaining methods are included for compatibility with the
+     * Java 2 platform Vector class.
+     */
+
+    /**
+     * Returns an array containing all of the elements in this list in the
+     * correct order.
+     *
+     * @return an array containing the elements of the list
+     * @see Vector#toArray()
+     */
+    public Object[] toArray() {
+        Object[] rv = new Object[delegate.size()];
+        delegate.copyInto(rv);
+        return rv;
+    }
+
+    /**
+     * Returns the element at the specified position in this list.
+     *
+     * @param index index of element to return
+     * @return the element at the specified position in this list
+     * @throws ArrayIndexOutOfBoundsException if the index is out of range
+     * ({@code index &lt; 0 || index &gt;= size()})
+     */
+    public E get(int index) {
+        return delegate.elementAt(index);
+    }
+
+    /**
+     * Replaces the element at the specified position in this list with the
+     * specified element.
+     *
+     * @param index index of element to replace
+     * @param element element to be stored at the specified position
+     * @return the element previously at the specified position
+     * @throws ArrayIndexOutOfBoundsException if the index is out of range
+     * ({@code index &lt; 0 || index &gt;= size()})
+     */
+    public E set(int index, E element) {
+        E rv = delegate.elementAt(index);
+        delegate.setElementAt(element, index);
+        fireContentsChanged(this, index, index);
+        return rv;
+    }
+
+    /**
+     * Inserts the specified element at the specified position in this list.
+     *
+     * @param index index at which the specified element is to be inserted
+     * @param element element to be inserted
+     * @throws ArrayIndexOutOfBoundsException if the index is out of range
+     * ({@code index &lt; 0 || index &gt; size()})
+     */
+    public void add(int index, E element) {
+        delegate.insertElementAt(element, index);
+        fireIntervalAdded(this, index, index);
+    }
+
+    /**
+     * Removes the element at the specified position in this list.
+     * Returns the element that was removed from the list
+     *
+     * @param index the index of the element to removed
+     * @return the element previously at the specified position
+     * @throws ArrayIndexOutOfBoundsException if the index is out of range
+     * ({@code index &lt; 0 || index &gt;= size()})
+     */
+    public E remove(int index) {
+        E rv = delegate.elementAt(index);
+        delegate.removeElementAt(index);
+        fireIntervalRemoved(this, index, index);
+        return rv;
+    }
+
+    /**
+     * Removes all of the elements from this list.  The list will
+     * be empty after this call returns (unless it throws an exception).
+     */
+    public void clear() {
+        int index1 = delegate.size()-1;
+        delegate.removeAllElements();
+        if (index1 >= 0) {
+            fireIntervalRemoved(this, 0, index1);
+        }
+    }
+
+    /**
+     * Deletes the components at the specified range of indexes.
+     * The removal is inclusive, so specifying a range of (1,5)
+     * removes the component at index 1 and the component at index 5,
+     * as well as all components in between.
+     *
+     * @param      fromIndex the index of the lower end of the range
+     * @param      toIndex   the index of the upper end of the range
+     * @throws ArrayIndexOutOfBoundsException if the index was invalid
+     * @throws IllegalArgumentException if {@code fromIndex &gt; toIndex}
+     * @see        #remove(int)
+     */
+    public void removeRange(int fromIndex, int toIndex) {
+        if (fromIndex > toIndex) {
+            throw new IllegalArgumentException("fromIndex must be <= toIndex");
+        }
+        for(int i = toIndex; i >= fromIndex; i--) {
+            delegate.removeElementAt(i);
+        }
+        fireIntervalRemoved(this, fromIndex, toIndex);
+    }
+
+    /**
+     * Adds all of the elements present in the collection to the list.
+     *
+     * @param c the collection which contains the elements to add
+     * @throws NullPointerException if {@code c} is null
+     */
+    public void addAll(Collection<? extends E> c) {
+        if (c.isEmpty()) {
+            return;
+        }
+
+        int startIndex = getSize();
+
+        delegate.addAll(c);
+        fireIntervalAdded(this, startIndex, getSize() - 1);
+    }
+
+    /**
+     * Adds all of the elements present in the collection, starting
+     * from the specified index.
+     *
+     * @param index index at which to insert the first element from the
+     * specified collection
+     * @param c the collection which contains the elements to add
+     * @throws ArrayIndexOutOfBoundsException if {@code index} does not
+     * fall within the range of number of elements currently held
+     * @throws NullPointerException if {@code c} is null
+     */
+    public void addAll(int index, Collection<? extends E> c) {
+        if (index < 0 || index > getSize()) {
+            throw new ArrayIndexOutOfBoundsException("index out of range: " +
+                                                                       index);
+        }
+
+        if (c.isEmpty()) {
+            return;
+        }
+
+        delegate.addAll(index, c);
+        fireIntervalAdded(this, index, index + c.size() - 1);
+    }
+
+	@Override
+	public void writeExternal(ObjectOutput out) throws IOException {
+		out.writeObject(delegate);
+		
+	}
+
+	@Override
+	public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+		delegate=(Vector<E>) in.readObject();
+	}
+}
@@ -0,0 +1,396 @@
+package org.kne.cloud.network;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * 修复的BufferedChannel，解决Socket关闭时的数据一致性问题
+ */
+public class BufferedChannel implements ReadableByteChannel, WritableByteChannel, ScatteringByteChannel, GatheringByteChannel {
+    private final ReadableByteChannel inputChannel;
+    private final WritableByteChannel outputChannel;
+    private final ByteBuffer readBuffer;
+    private final ByteBuffer writeBuffer;
+    
+    
+   // private final AtomicBoolean closed = new AtomicBoolean(false);
+    private final AtomicBoolean inputShutdown = new AtomicBoolean(false);
+    private final AtomicBoolean outputShutdown = new AtomicBoolean(false);
+
+    public BufferedChannel(ReadableByteChannel channel, int bufferSize) {
+        this(channel, null, bufferSize);
+    }
+    
+    public BufferedChannel(WritableByteChannel channel, int bufferSize) {
+        this(null, channel, bufferSize);
+    }
+    
+    public BufferedChannel(ReadableByteChannel inputChannel, WritableByteChannel outputChannel, int bufferSize) {
+        this.inputChannel = inputChannel;
+        this.outputChannel = outputChannel;
+        this.readBuffer = ByteBuffer.allocateDirect(bufferSize);
+        this.writeBuffer = ByteBuffer.allocateDirect(bufferSize);
+        
+        // 更安全的初始化
+        this.readBuffer.limit(0); // 明确设置为空
+        this.writeBuffer.clear();
+    }
+
+    @Override
+    public int read(ByteBuffer dst) throws IOException {
+        if ( inputShutdown.get()) {
+            throw new ClosedChannelException();
+        }
+        
+       
+            // 检查底层通道是否仍然打开
+            if (inputChannel != null && !inputChannel.isOpen()) {
+                inputShutdown.set(true);
+                return handleInputShutdown();
+            }
+            
+            int totalRead = 0;
+            boolean eofEncountered = false;
+            
+            while (dst.hasRemaining() && !eofEncountered) {
+                // 如果读缓冲区有数据，先从中读取
+                if (readBuffer.hasRemaining()) {
+                    int bytesToCopy = Math.min(readBuffer.remaining(), dst.remaining());
+                    
+                    // 使用绝对位置操作，避免修改缓冲区状态
+                    int oldlimit=readBuffer.limit();
+                    readBuffer.limit(readBuffer.position()+bytesToCopy);
+                        dst.put(readBuffer);
+                        readBuffer.limit(oldlimit);
+                    
+                    totalRead += bytesToCopy;
+                    continue;
+                }
+                
+                // 读缓冲区空了，需要重新填充
+                readBuffer.clear();
+                int bytesRead;
+                try {
+                    bytesRead = inputChannel.read(readBuffer);
+                } catch (IOException e) {
+                    // 读取时发生IO异常，标记为关闭
+                    inputShutdown.set(true);
+                    throw e;
+                }
+                
+                if (bytesRead == -1) {
+                    // 到达EOF
+                    inputShutdown.set(true);
+                    eofEncountered = true;
+                } else if (bytesRead == 0) {
+                    // 没有数据可用，可能是非阻塞模式
+                    break;
+                } else {
+                    readBuffer.flip();
+                }
+            }
+            
+            // 如果遇到EOF且没有读取到任何数据，返回-1
+            if (eofEncountered && totalRead == 0) {
+                return -1;
+            }
+            
+            return totalRead;
+         
+    }
+
+    /**
+     * 处理输入关闭的情况
+     */
+    private int handleInputShutdown() throws IOException {
+        // 如果读缓冲区还有剩余数据，先返回这些数据
+        if (readBuffer.hasRemaining()) {
+            return readBuffer.remaining();
+        }
+        return -1;
+    }
+
+    @Override
+    public long read(ByteBuffer[] dsts) throws IOException {
+        return read(dsts, 0, dsts.length);
+    }
+
+    @Override
+    public long read(ByteBuffer[] dsts, int offset, int length) throws IOException {
+       
+        
+        long totalRead = 0;
+        for (int i = offset; i < offset + length; i++) {
+            ByteBuffer dst = dsts[i];
+            if (dst == null) {
+                throw new NullPointerException("Destination buffer is null");
+            }
+            
+            int bytesRead = read(dst);
+            if (bytesRead == -1) {
+                // 只有在没有读取任何数据时才返回-1
+                return totalRead > 0 ? totalRead : -1;
+            }
+            totalRead += bytesRead;
+        }
+        
+        return totalRead;
+    }
+
+    @Override
+    public int write(ByteBuffer src) throws IOException {
+       
+        
+      
+            // 检查底层通道是否仍然打开
+            if (outputChannel != null && !outputChannel.isOpen()) {
+                outputShutdown.set(true);
+                throw new ClosedChannelException();
+            }
+            
+            int totalWritten = 0;
+            
+            while (src.hasRemaining()) {
+                // 如果写缓冲区有空间，先填充
+                if (writeBuffer.hasRemaining()) {
+                    int bytesToCopy = Math.min(writeBuffer.remaining(), src.remaining());
+                   int oldlimit= src.limit();
+                   src.limit(src.position()+bytesToCopy);
+                        writeBuffer.put(src);
+                        src.limit(oldlimit);
+                    
+                    totalWritten += bytesToCopy;
+                }
+                
+                // 如果写缓冲区满了或者源数据还很多，刷新缓冲区
+                if (!writeBuffer.hasRemaining() ) {
+                    try {
+                        flushInternal();
+                    } catch (IOException e) {
+                        outputShutdown.set(true);
+                        throw e;
+                    }
+                }
+            }
+            return totalWritten;
+            
+       
+    }
+
+    @Override
+    public long write(ByteBuffer[] srcs) throws IOException {
+        return write(srcs, 0, srcs.length);
+    }
+
+    @Override
+    public long write(ByteBuffer[] srcs, int offset, int length) throws IOException {
+       
+        
+        long totalWritten = 0;
+        for (int i = offset; i < offset + length; i++) {
+            ByteBuffer src = srcs[i];
+            if (src == null) {
+                throw new NullPointerException("Source buffer is null");
+            }
+            
+            int bytesWritten = write(src);
+            totalWritten += bytesWritten;
+        }
+        
+        return totalWritten;
+    }
+
+    /**
+     * 安全的刷新方法
+     */
+    public void flush() throws IOException {
+        
+        
+        if (outputChannel == null || outputShutdown.get()) {
+            return;
+        }
+        
+        try {
+            flushInternal();
+        } catch (IOException e) {
+            outputShutdown.set(true);
+            throw e;
+        } 
+    }
+
+    /**
+     * 内部刷新方法，假设已经持有writeLock
+     */
+    private void flushInternal() throws IOException {
+        if (writeBuffer.position() > 0) {
+            writeBuffer.flip();
+            
+            try {
+                while (writeBuffer.hasRemaining()) {
+                    int written = outputChannel.write(writeBuffer);
+                   // System.out.println("发送"+written);
+                    if (written == 0) {
+                        // 可能遇到阻塞或关闭
+                        if (!outputChannel.isOpen()) {
+                            outputShutdown.set(true);
+                            throw new ClosedChannelException();
+                        }
+                        // 给其他操作机会
+                        Thread.yield();
+                    }
+                }
+            } finally {
+                // 无论发生什么，确保写缓冲区处于可写状态
+                writeBuffer.clear();
+            }
+        }
+    }
+
+    /**
+     * 安全的关闭方法
+     */
+    @Override
+    public void close() throws IOException {
+        
+        
+        IOException exception = null;
+        
+        // 先刷新输出缓冲区
+        if (outputChannel != null && !outputShutdown.get()) {
+         
+                if (writeBuffer.position() > 0) {
+                    try {
+                        flushInternal();
+                    } catch (IOException e) {
+                        exception = e;
+                    }
+                }
+         
+        }
+        
+        // 关闭底层通道
+        try {
+            if (inputChannel != null) {
+                inputChannel.close();
+            }
+        } catch (IOException e) {
+            if (exception == null) {
+                exception = e;
+            } else {
+                exception.addSuppressed(e);
+            }
+        }
+        
+        try {
+            if (outputChannel != null) {
+                outputChannel.close();
+            }
+        } catch (IOException e) {
+            if (exception == null) {
+                exception = e;
+            } else {
+                exception.addSuppressed(e);
+            }
+        }
+        
+        // 清理缓冲区状态
+      
+            readBuffer.clear();
+            readBuffer.limit(0); // 标记为已清空
+        
+        
+        
+            writeBuffer.clear();
+       
+        
+        // 设置关闭状态
+        inputShutdown.set(true);
+        outputShutdown.set(true);
+        
+        if (exception != null) {
+            throw exception;
+        }
+    }
+
+    /**
+     * 优雅关闭 - 只关闭输入或输出
+     */
+    public void shutdownInput() throws IOException {
+        inputShutdown.set(true);
+        
+            readBuffer.clear();
+            readBuffer.limit(0);
+        
+        
+        if (inputChannel instanceof SocketChannel) {
+            ((SocketChannel) inputChannel).shutdownInput();
+        }
+    }
+    
+    public void shutdownOutput() throws IOException {
+        outputShutdown.set(true);
+        
+            if (writeBuffer.position() > 0) {
+                flushInternal();
+            }
+       
+        
+        if (outputChannel instanceof SocketChannel) {
+            ((SocketChannel) outputChannel).shutdownOutput();
+        }
+    }
+
+    @Override
+    public boolean isOpen() {
+        return 
+               (inputChannel == null || inputChannel.isOpen()) && 
+               (outputChannel == null || outputChannel.isOpen());
+    }
+
+    /**
+     * 检查是否还有可读数据（包括缓冲区中的）
+     */
+    public boolean hasRemaining() throws IOException {
+        if ( inputShutdown.get()) {
+            return false;
+        }
+        
+        
+            return readBuffer.hasRemaining() || 
+                   (inputChannel != null && inputChannel.isOpen());
+        
+    }
+
+    /**
+     * 获取缓冲区状态信息（用于调试）
+     */
+    public String getBufferState() {
+        
+            return String.format(
+                "ReadBuffer[pos=%d, lim=%d, cap=%d], WriteBuffer[pos=%d, lim=%d, cap=%d], " +
+                "closed=%b, inputShutdown=%b, outputShutdown=%b",
+                readBuffer.position(), readBuffer.limit(), readBuffer.capacity(),
+                writeBuffer.position(), writeBuffer.limit(), writeBuffer.capacity(), inputShutdown.get(), outputShutdown.get()
+            );
+       
+    }
+
+    // 其他方法保持不变...
+    public int available() throws IOException {
+        if ( inputShutdown.get()) {
+            return 0;
+        }
+        
+      
+            return readBuffer.remaining();
+       
+    }
+
+    public long skip(long n) throws IOException {
+        // 实现保持不变...
+        return 0;
+    }
+}
@@ -0,0 +1,36 @@
+package org.kne.cloud.network;
+
+import java.util.Queue;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+public class ByteArrayPool {
+	private  Queue<byte[]> rec;
+	private int maxcount;
+	private int length;
+	public ByteArrayPool(int maxcount, int length) {
+		super();
+		this.maxcount = maxcount;
+		this.length = length;
+		rec=new ConcurrentLinkedQueue<byte[]>();
+	}
+	public void back(byte[]b) {
+		if(b.length!=length)
+			throw new IllegalArgumentException("wrong length");
+		rec.offer(b);
+	}
+	public byte[] borrow() {
+		byte[]b=rec.poll();
+		if(b==null) {
+			b=new byte[length];
+		}
+		return b;
+	}
+	public int getMaxCount() {
+		return maxcount;
+	}
+	public int getLength() {
+		return length;
+	}
+	
+}
@@ -0,0 +1,41 @@
+package org.kne.cloud.network;
+
+import java.lang.foreign.Arena;
+import java.nio.ByteBuffer;
+
+import org.kne.membandboost.MembandBoost;
+
+public class ByteBufferAllocator {
+	
+	public ByteBufferAllocator(boolean isDirect) {
+		
+	}
+	public ByteBuffer allocate(int capacity) {
+		//if(capacity<1024)
+		return allocateHeap(capacity);
+		//	return allocateNative(capacity);
+	
+		
+	}
+	//private Arena ar=BufferedArena.ofBuffered();
+	//private Arena ara=Arena.ofAuto();
+	public ByteBuffer allocateNative(int capacity) {
+		//return ((jdk.internal.foreign.ArenaImpl)ara).allocateNoInit(capacity,1).asByteBuffer();
+		
+		ByteBuffer buf=Arena.ofAuto().allocate(capacity).asByteBuffer();
+		if(buf.capacity()!=capacity)
+			throw new InternalError();
+		return buf;
+	}
+	
+	
+	public static ByteBuffer allocateHeap(int capacity) {
+		/*if(capacity<=2048) {
+		return MembandBoost.allocateUninitializedHeapBufferBlocked(capacity);
+		}else {*/
+			return MembandBoost.allocateUninitializedHeapBuffer(capacity);
+		//}
+	}
+	
+	
+}
@@ -0,0 +1,79 @@
+package org.kne.cloud.network;
+
+import java.nio.ByteBuffer;
+import java.util.Queue;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReferenceArray;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+import org.kne.concurrent.SpinLock;
+import org.kne.debug.TimeDebugger;
+
+
+public class ByteBufferPool {
+	private AtomicReferenceArray< ByteBuffer> rec;
+	private volatile AtomicInteger pos=new AtomicInteger( 0);
+	//private Lock lock=new SpinLock();
+	
+	private int maxcount;
+	private int length;
+	private int mcj;
+	private boolean direct;
+	public ByteBufferPool(int maxcount, int length,boolean direct) {
+		super();
+		this.maxcount = maxcount;
+		this.length = length;
+		this.direct=direct;
+		rec=new AtomicReferenceArray<ByteBuffer>(maxcount);
+		mcj= rec.length()-1;
+	}
+	public ByteBufferPool(int maxcount, int length) {
+		this(maxcount, length, true);
+	}
+	public void back(ByteBuffer b) {
+		if(b.capacity()!=length)
+			throw new IllegalArgumentException("wrong length");
+		b.clear();
+		
+		
+			if(pos.get()<=mcj) {
+				int d=pos.getAndIncrement();
+				if(d>mcj) 
+					d=mcj;
+				if(d<0)
+				d=0;
+		rec.compareAndSet(d,null,b);
+			}
+		
+	}
+	public ByteBuffer borrow() {
+		ByteBuffer b=null;
+		
+			if(pos.get()>0) {
+				int d=pos.decrementAndGet();
+				if(d>mcj) 
+					d=mcj;
+				if(d<0)
+				d=0;
+			b=rec.getAndSet(d,null);
+			}
+		
+		if(b==null) {
+			if(direct)
+			b=ByteBuffer.allocateDirect(length);
+			else
+				b=ByteBuffer.allocate(length);
+		}
+		return b;
+	}
+	public int getMaxCount() {
+		return maxcount;
+	}
+	public int getLength() {
+		return length;
+	}
+	
+}
@@ -0,0 +1,92 @@
+package org.kne.cloud.network;
+
+import java.io.*;
+import java.nio.ByteBuffer;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.channels.WritableByteChannel;
+import java.util.Objects;
+import java.util.UUID;
+
+import org.kne.io.Task;
+
+public class ChannelBridge extends Task{
+	protected ReadableByteChannel in;
+	protected WritableByteChannel out;
+	protected int blocksize=65535;
+	protected long delay=0;
+	public ChannelBridge(ReadableByteChannel in, WritableByteChannel out) {
+		super();
+		Objects.requireNonNull(in);
+		Objects.requireNonNull(out);
+		this.in = in;
+		this.out = out;
+	}
+	
+	@Override
+	public void runTask() {
+		//FileOutputStream fos=null;
+		try {
+			//fos=new FileOutputStream(UUID.randomUUID()+".txt");
+		ByteBuffer b=ByteBuffer.allocateDirect(blocksize);
+			while (in.read(b)!=-1) {
+				b.flip();
+				out.write(b);
+				b.clear();
+				if(delay>0) {
+				try {
+					Thread.sleep(delay);
+				} catch (InterruptedException e) {
+					e.printStackTrace();
+				}
+				}else {
+					Thread.yield();
+				}
+			}
+		} catch (IOException e) {
+			e.printStackTrace();
+		}finally {
+			/*if(fos!=null)
+				try {
+					fos.close();
+				} catch (IOException e1) {
+					e1.printStackTrace();
+				}*/
+			try {
+				if(in!=null)
+				in.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			try {
+				if(in!=null)
+				out.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+	public int getBlocksize() {
+		return blocksize;
+	}
+
+	public void setBlocksize(int blocksize) {
+		this.blocksize = blocksize;
+	}
+	public long getDelay() {
+		return delay;
+	}
+
+	public void setDelay(long delay) {
+		this.delay = delay;
+	}
+
+	public void runAtNewThread() {
+		runAtNewThread("StreamBridge thread");
+	}
+	public Thread runAtNewThread(String name) {
+		Thread t=ThreadTool.makeVThreadIfSupport(name, this);
+		t.start();
+		return t;
+	}
+	
+}
@@ -0,0 +1,359 @@
+package org.kne.cloud.network;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.NetworkInterface;
+import java.net.SocketAddress;
+import java.net.SocketException;
+import java.net.SocketTimeoutException;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.LockSupport;
+
+public class DatagramServerSocket implements java.io.Closeable{
+	public static final ByteArrayPool dataarraypool=new ByteArrayPool(100, 65535);
+	
+	private boolean closed=false;
+	private boolean bound=false;
+	private DatagramSocketFactory dgsf;
+	private Set<DatagramDistributor> skts=new HashSet<>();
+    private final Object stateLock = new Object();
+    private BlockingQueue<DatagramSocket> recs;
+	private InetSocketAddress bindpoint;
+	 
+	
+	
+	
+	
+	public DatagramServerSocket() throws SocketException {
+		this(new DefaultDatagramSocketFactory());
+	}
+
+	protected DatagramServerSocket(DatagramSocketFactory impl) throws SocketException {
+		this.dgsf=impl;
+	}
+
+	public DatagramServerSocket(int port, InetAddress laddr) throws SocketException {
+		this(new DefaultDatagramSocketFactory());
+		bind(new InetSocketAddress(laddr, port));
+	}
+
+	public DatagramServerSocket(int port) throws SocketException {
+		this(new DefaultDatagramSocketFactory());
+		bind(new InetSocketAddress(port));
+	}
+
+	public DatagramServerSocket(SocketAddress bindaddr) throws SocketException {
+		this(new DefaultDatagramSocketFactory());
+		bind(bindaddr);
+	}
+
+	public DatagramServerSocket(int port, int backlog) throws SocketException {
+		this(new DefaultDatagramSocketFactory());
+		bind(new InetSocketAddress(port));
+	}
+	
+	public DatagramServerSocket(int port, int backlog, InetAddress laddr) throws SocketException {
+		this(new DefaultDatagramSocketFactory());
+		bind(new InetSocketAddress(laddr, port));
+	}
+	 public void bind(SocketAddress endpoint) throws SocketException {
+	        bind(endpoint, 50);
+	    }
+	 public void bind(SocketAddress endpoint, int backlog) throws SocketException {
+	        if (isClosed())
+	            throw new SocketException("Socket is closed");
+	        if (isBound())
+	            throw new SocketException("Already bound");
+	        if (endpoint == null)
+	            endpoint = new InetSocketAddress(0);
+	        if (!(endpoint instanceof InetSocketAddress epoint))
+	            throw new IllegalArgumentException("Unsupported address type");
+	        if (epoint.isUnresolved())
+	            throw new SocketException("Unresolved address");
+	        if (backlog < 1)
+	            backlog = 50;
+
+
+
+	        synchronized (stateLock) {
+	            if (closed)
+	                throw new SocketException("Socket is closed");
+	            if (bound)
+	                throw new SocketException("Already bound");
+	            bind0(epoint);
+	            recs=new ArrayBlockingQueue<DatagramSocket>(backlog);
+	            bound = true;
+	        }
+	    }
+
+	
+	private void bind0(InetSocketAddress epoint) throws SocketException {
+		bindpoint=epoint;
+		if(epoint.getAddress().isAnyLocalAddress()) {
+				Enumeration<NetworkInterface>eu= NetworkInterface.getNetworkInterfaces();
+				while (eu.hasMoreElements()) {
+					NetworkInterface networkInterface = (NetworkInterface) eu.nextElement();
+					if(networkInterface.isUp()) {
+					//System.out.println(networkInterface+" "+networkInterface.isUp());
+					Enumeration<InetAddress>ei= networkInterface.getInetAddresses();
+					while (ei.hasMoreElements()) {
+						InetAddress inetAddress = (InetAddress) ei.nextElement();
+						DatagramDistributor dd=new DatagramDistributor(new InetSocketAddress(inetAddress, epoint.getPort()));
+						skts.add(dd);
+					}
+					}
+				}
+						
+		}else {
+			DatagramDistributor dd=new DatagramDistributor(epoint);
+			skts.add(dd);
+		}
+	}
+	private class DatagramDistributor implements Runnable{
+		private Map<SocketAddress,SubDatagramSocket> clients=new ConcurrentHashMap<>();
+
+		private InetSocketAddress epoint;
+		private DatagramSocket datagramSocket;
+		public DatagramDistributor(InetSocketAddress epoint) throws SocketException {
+			this.epoint=epoint;
+			datagramSocket=new DatagramSocket(epoint);
+			ThreadTool.makeVDaemonThreadIfSupport("Datagram Distribute Thread", this).start();
+		}
+		
+		public DatagramSocket getDatagramSocket() {
+			return datagramSocket;
+		}
+
+		@Override
+		public void run() {
+			try {
+			while(!closed) {
+			byte[]data=dataarraypool.borrow();
+			DatagramPacket dp=new DatagramPacket(data,data.length);
+				datagramSocket.receive(dp);
+				//System.out.println("get:"+dp);
+				SubDatagramSocket sdds=clients.get(dp.getSocketAddress());
+				if(sdds==null) {
+					if(recs.remainingCapacity()>1) {
+					sdds=new SubDatagramSocket(epoint, (InetSocketAddress) dp.getSocketAddress(),this );
+					if(recs.offer(sdds))
+					clients.put(dp.getSocketAddress(), sdds);
+					}
+					
+				}
+				if(sdds!=null) {
+					//System.out.println("give:"+dp);
+				sdds.givePacket(dp);
+				}
+				
+			}
+			} catch (IOException e) {
+				// TODO 自动生成的 catch 块
+				e.printStackTrace();
+			}
+		}
+
+		public void removeClient(SubDatagramSocket subDatagramSocket) {
+			clients.remove(subDatagramSocket.getRemoteSocketAddress());
+		}
+
+		public void close() {
+			datagramSocket.close();
+		}
+		
+	}
+	public DatagramSocket accept()throws IOException{
+		while(true) {
+			if(isClosed())
+				throw new SocketException("DatagramServerSocket closed");
+	        if (!isBound())
+	            throw new SocketException("DatagramServerSocket is not bound yet");
+			DatagramSocket sds=	recs.poll();
+			if(sds!=null) {
+				return sds;
+			}
+			try {
+				Thread.sleep(5);
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+	private boolean isClosed() {
+		return closed;
+	}
+
+	private boolean isBound() {
+		return bound;
+	}
+	public class SubDatagramSocket extends DatagramSocket{
+		private DatagramDistributor parent;
+		private InetSocketAddress local;
+		private InetSocketAddress remote;
+		private boolean closed=false;
+		private int timeout=0;
+		private BlockingQueue<DatagramPacket> recs=new ArrayBlockingQueue(100);
+		private volatile Thread t;
+		private void unwait() {
+			if(t!=null)
+			LockSupport.unpark(t);
+		}
+		
+		public SubDatagramSocket(InetSocketAddress local,InetSocketAddress remote,DatagramDistributor datagramDistributor) throws SocketException {
+			super((SocketAddress)null);
+			this.local=local;
+			this.remote=remote;
+			this.parent=datagramDistributor;
+		}
+
+		protected boolean givePacket(DatagramPacket dp) {
+			boolean b=recs.offer(dp);
+			unwait();
+			return b;
+		}
+		public DatagramPacket receive()throws IOException{
+			long start=System.nanoTime();
+			while(true) {
+				if(closed) {
+					throw new SocketException("DatagramSocket closed");
+				}
+				DatagramPacket dp=recs.poll();
+				if(dp!=null) {
+					
+					return dp;
+				}
+				if(timeout!=0) {
+				long dms=(System.nanoTime()-start)/1000000;
+				if(dms>timeout)
+					throw new SocketTimeoutException("Receive Time Out");
+				}
+				t=Thread.currentThread();
+				LockSupport.parkNanos(1000000);
+			}
+		}
+		@Override
+		public void receive(DatagramPacket p) throws IOException {
+				DatagramPacket dp=null;
+				long start=System.nanoTime();
+				while(true) {
+					if(closed) {
+						throw new SocketException("DatagramSocket closed");
+					}
+					dp=recs.poll();
+					if(dp!=null) {
+						p.setLength(dp.getLength());
+					System.arraycopy(dp.getData(), dp.getOffset(), p.getData(), p.getOffset(), dp.getLength());
+						dataarraypool.back(dp.getData());
+						break;
+					}
+					if(timeout!=0) {
+					long dms=(System.nanoTime()-start)/1000000;
+					if(dms>timeout)
+						throw new SocketTimeoutException("Receive Time Out");
+					}
+					t=Thread.currentThread();
+					LockSupport.parkNanos(1000000);
+				}
+		}
+
+		@Override
+		public void send(DatagramPacket p) throws IOException {
+			p.setSocketAddress(remote);
+			parent.getDatagramSocket().send(p);
+		}
+		
+		@Override
+		public SocketAddress getRemoteSocketAddress() {
+			return remote;
+		}
+
+		@Override
+		public InetAddress getInetAddress() {
+			return remote.getAddress();
+		}
+
+		@Override
+		public int getPort() {
+			return remote.getPort();
+		}
+
+		@Override
+		public SocketAddress getLocalSocketAddress() {
+			return local;
+		}
+
+		@Override
+		public InetAddress getLocalAddress() {
+			return local.getAddress();
+		}
+
+		@Override
+		public int getLocalPort() {
+			return local.getPort();
+		}
+
+		@Override
+		public void setSoTimeout(int timeout) throws SocketException {
+			this.timeout=timeout;
+		}
+		
+		
+		@Override
+		public int getSoTimeout() throws SocketException {
+			return timeout;
+		}
+
+		@Override
+		public void close() {
+			if(!closed)
+				parent.removeClient(this);
+			closed=true;
+		}
+
+		@Override
+		public boolean isClosed() {
+			return closed;
+		}
+	
+		
+		
+	}
+	
+	@Override
+	public void close() {
+		closed=true;
+		for (Iterator<DatagramDistributor> iterator = skts.iterator(); iterator.hasNext();) {
+			DatagramDistributor datagramSocket = (DatagramDistributor) iterator.next();
+			datagramSocket.close();
+		}
+	}
+	
+	public SocketAddress getLocalSocketAddress() {
+        return bindpoint;
+    }
+	
+	
+	public InetAddress getLocalAddress() {
+		 if(bindpoint==null)
+	    	   return null;
+	       else
+	    	   return bindpoint.getAddress();
+	}
+
+	public int getLocalPort() {
+       if(bindpoint==null)
+    	   return -1;
+       else
+    	   return bindpoint.getPort();
+    }
+}
@@ -0,0 +1,18 @@
+package org.kne.cloud.network;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.SocketAddress;
+
+public abstract class DatagramServerSocketFactory {
+	public DatagramServerSocket createDatagramServerSocket() throws IOException {
+		return new DatagramServerSocket((SocketAddress)null);
+	}
+
+	public abstract DatagramServerSocket createDatagramServerSocket(int port) throws IOException;
+
+	public abstract DatagramServerSocket createDatagramServerSocket(int port, int backlog) throws IOException;
+
+	public abstract DatagramServerSocket createDatagramServerSocket(int port, int backlog, InetAddress ifAddress) throws IOException;
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
KNEMC	2dd62ec7c4	KLALB 3.6.0开发一半的状态	2026-07-06 17:16:33 +08:00
KNEMC	c8b183da71	KLALB 3.6.0开发一半的状态	2026-07-06 17:03:27 +08:00
Administrator	620afef715	KLALB V3.6.0 写了一半	2026-02-27 08:32:03 +08:00
Administrator	816e672843	ADD License	2025-11-15 11:19:43 +08:00
Administrator	8842566ee2	KLALB V3.4	2025-11-15 11:08:16 +08:00
Administrator	306bfd36f7	UI改进	2025-08-08 17:13:27 +08:00
Administrator	7267aec1fd	KLALB3.2	2025-04-24 10:16:38 +08:00
Administrator	6de65562be	优化代码，性能暴涨	2025-01-29 14:01:11 +08:00
Administrator	e243203535	KLALB2.3	2024-08-18 17:47:11 +08:00
Administrator	e4f4c77c19	UPDATE 2.2	2024-01-30 16:54:57 +08:00