aview-app 1.0.2

package/aardio/lib/wsock/addrInfo.aardio

@@ -0,0 +1,74 @@
+//addrInfo 地址解析
+
+import wsock;
+namespace wsock;
+
+class addrInfo{
+	ctor(){
+		this = addr_info();
+		this.socktype = 0x1/*_SOCK_STREAM*/;
+		this.protocol = 0x6/*_IPPROTO_TCP*/;
+	};
+	query = function(hostname){
+		..wsock.open();
+	
+		var ai = { ptr next }
+		var ret = ::Ws2_32.getaddrinfo(hostname, 0, this, ai);
+		if ( ret != 0 ) {
+			..wsock.close();
+    		return null,..wsock.err.lasterr(); 
+		}
+		
+		var result = {};
+		var first = ai.next;
+		while(ai.next){ 
+			ai = ..raw.convert( ai.next, addr_info() )
+			 
+    		select(ai.family) {
+    			case 0x2/*_AF_INET*/ {
+    				ai.addr = ..raw.convert( ai.addr,..wsock.sockaddr_in()); 
+    			}
+    			case 23/*_AF_INET6*/{
+    				ai.addr = ..raw.convert( ai.addr,..wsock.sockaddr_in6()); 
+    			}
+    			else {
+    				continue;
+    			}
+    		}
+			
+			..table.push(result,ai);
+		}
+		
+		::Ws2_32.freeaddrinfo(first);
+		
+		..wsock.close();
+		return result;
+	};
+	queryIp = function(hostname){
+		if(!hostname) return { ..wsock.getIp() };
+		
+		var ips = this.query(hostname);
+		return ..table.map(ips,lambda(v) tostring(v.addr.sin_addr || v.addr.sin6_addr) );
+	};
+}
+
+namespace addrInfo{
+    
+	class  addr_info {  
+		int	flags=2; 
+		int	family;  
+		int	socktype; 
+		int	protocol;  
+		INT	addrlen; 
+		string canonname;  
+		ptr	addr;  
+		ptr	next;
+	} 
+}
+
+/**intellisense()
+wsock.addrInfo = IP地址解析
+wsock.addrInfo() = 创建IP地址解析器\n!wsockaddrinfo.
+!wsockaddrinfo.query(__/*主机名*/) = 解析域名并返回addrInfo结构体数组\n参数不能为空
+!wsockaddrinfo.queryIp(__/*主机名*/) = 解析域名并返回IP地址数组\n参数为空获取本机网卡IP列表
+end intellisense**/

package/aardio/lib/wsock/err.aardio

@@ -0,0 +1,115 @@
+//err 错误信息列表
+namespace wsock.err;
+
+message = {
+[6]="Specified event object handle is invalid";
+[8]="Insufficient memory available";
+[87]="One or more parameters are invalid";
+[995]="Overlapped operation aborted";
+[996]="Overlapped I/O event object not in signaled state";
+[997]="Overlapped operations will complete later";
+[10004]="Interrupted function call";
+[10009]="File handle is not valid";
+[10013]="Permission denied"; //端口被占用参考inet.stat()
+[10014]="Bad address";
+[10022]="Invalid argument";
+[10024]="Too many open files";
+[10035]="Resource temporarily unavailable";
+[10036]="Operation now in progress";
+[10037]="Operation already in progress";
+[10038]="Socket operation on nonsocket";
+[10039]="Destination address required";
+[10040]="Message too long";
+[10041]="Protocol wrong type for socket";
+[10042]="Bad protocol option";
+[10043]="Protocol not supported";
+[10044]="Socket type not supported";
+[10045]="Operation not supported";
+[10046]="Protocol family not supported";
+[10047]="Address family not supported by protocol family";
+[10048]="Address already in use";
+[10049]="Cannot assign requested address";
+[10050]="Network is down";
+[10051]="Network is unreachable";
+[10052]="Network dropped connection on reset";
+[10053]="Software caused connection abort";
+[10054]="Connection reset by peer";
+[10055]="No buffer space available";
+[10056]="Socket is already connected";
+[10057]="Socket is not connected";
+[10058]="Cannot send after socket shutdown";
+[10059]="Too many references";
+[10060]="Connection timed out";
+[10061]="Connection refused";
+[10062]="Cannot translate name";
+[10063]="Name too long";
+[10064]="Host is down";
+[10065]="No route to host";
+[10066]="Directory not empty";
+[10067]="Too many processes";
+[10068]="User quota exceeded";
+[10069]="Disk quota exceeded";
+[10070]="Stale file handle reference";
+[10071]="Item is remote";
+[10091]="Network subsystem is unavailable";
+[10092]="Winsock.dll version out of range";
+[10093]="Successful WSAStartup not yet performed";
+[10101]="Graceful shutdown in progress";
+[10102]="No more results";
+[10103]="Call has been canceled";
+[10104]="Procedure call table is invalid";
+[10105]="Service provider is invalid";
+[10106]="Service provider failed to initialize";
+[10107]="System call failure";
+[10108]="Service not found";
+[10109]="Class type not found";
+[10110]="No more results";
+[10111]="Call was canceled";
+[10112]="Database query was refused";
+[11001]="Host not found";
+[11002]="Nonauthoritative host not found";
+[11003]="This is a nonrecoverable error";
+[11004]="Valid name, no data record of requested type";
+[11005]="QoS receivers";
+[11006]="QoS senders";
+[11007]="No QoS senders";
+[11008]="QoS no receivers";
+[11009]="QoS request confirmed";
+[11010]="QoS admission error";
+[11011]="QoS policy failure";
+[11012]="QoS bad style";
+[11013]="QoS bad object";
+[11014]="QoS traffic control error";
+[11015]="QoS generic error";
+[11016]="QoS service type error";
+[11017]="QoS flowspec error";
+[11018]="Invalid QoS provider buffer";
+[11019]="Invalid QoS filter style";
+[11020]="Invalid QoS filter type";
+[11021]="Incorrect QoS filter count";
+[11022]="Invalid QoS object length";
+[11023]="Incorrect QoS flow count";
+[11024]="Unrecognized QoS object";
+[11025]="Invalid QoS policy object";
+[11026]="Invalid QoS flow descriptor";
+[11027]="Invalid QoS provider-specific flowspec";
+[11028]="Invalid QoS provider-specific filterspec";
+[11029]="Invalid QoS shape discard mode object";
+[11030]="Invalid QoS shaping rate object";
+[11031]="Reserved policy QoS element type";
+}
+	
+function lasterr(err) {
+	if(err === null) err = ::Ws2_32.WSAGetLastError()
+	if(!err)return;
+		
+	var msg = message[err] 
+	if(!msg) return ..lasterr(err);
+	else msg = msg + " #" + err;
+	
+	return msg,err;
+}
+
+/*intellisense(wsock.err)
+lasterr() = 可选在参数中指定错误代码,\n返回值为错误信息,错误码,\n没有错误则返回null\n[错误信息中文版](http://support.microsoft.com/kb/819124)
+end intellisense*/

package/aardio/lib/wsock/networkChange.aardio

@@ -0,0 +1,69 @@
+//networkChange 网络变更
+import wsock.tcp.client;
+namespace wsock.networkChange;
+
+var waitChanged = function(winform){
+	import wsock;
+	..wsock.open()
+	
+	var q = {
+		INT cbSize;
+		string lpszServiceInstanceName;
+		ptr lpServiceClassId;
+		ptr lpVersion;
+		string lpszComment;
+		INT dwNameSpace;
+		ptr lpNSProviderId;
+		string lpszContext;
+		INT dwNumberOfProtocols;
+		ptr lpafpProtocols;
+		string lpszQueryString;
+		INT dwNumberOfCsAddrs;
+		ptr lpcsaBuffer;
+		INT dwOutputFlags;
+		ptr lpBlob;
+	}
+	
+  	q.cbSize = ..raw.sizeof(q);  
+	q.dwNameSpace = 15/*_NS_NLA*/;  
+	
+  	do{
+		
+		var lookupHandle = {ptr p};  
+		::Ws2_32.WSALookupServiceBegin(q, 0x0FF0/*_LUP_RETURN_ALL*/, lookupHandle);  
+		if(lookupHandle.p){
+			::Ws2_32.WSANSPIoctl(lookupHandle.p, 0x88000019/*_SIO_NSP_NOTIFY_CHANGE*/, ,, ,,{INT bytes}, null);   
+			::Ws2_32.WSALookupServiceEnd(lookupHandle.p); 
+			if(winform) winform.onNetworkChanged(); 	
+		}
+		else {
+			break;
+		}
+		
+  	}while( winform && ::User32.IsWindow(winform.hwnd))
+	
+	..wsock.close();
+}
+
+wait = function(winform){
+	if(!winform) return waitChanged();
+	
+	if( !winform[["hwnd"]] ){
+		error('参数@1必须是窗口或控件对象!')
+	}
+	
+	if(!winform.onNetworkChanged) winform.onNetworkChanged = function(){}
+	..thread.invoke(waitChanged,winform);
+	
+	return winform; 
+}
+
+
+/**intellisense()
+wsock.networkChange = 检测网络变更，例如启用或禁用网卡
+wsock.networkChange.wait() = 等待网络变更，例如启用或禁用网卡。\n\n此函数不能用于获取网络连接状态,\n可使用 inet.http.isAlive,inet.ras.isAlive 等检测网络连接状态\n!wsock_NetworkChange.
+wsock.networkChange.wait(winform) = 等待网络变更，例如启用或禁用网卡。\n\n参数可指定回调窗口或控件对象,\n网络变更时回调窗口或控件的成员函数 onNetworkChanged\n此函数返回参数@1
+!wsock_NetworkChange.onNetworkChanged = @.onNetworkChanged = function(){
+	var ip = wsock.tcp.client.test(); __/*网络已变更，\n获取上网卡 IP 成功则为连接网络，否则为断开网络*/	
+}
+end intellisense**/

package/aardio/lib/wsock/tcp/asynClient.aardio

@@ -0,0 +1,320 @@
+//asynClient 异步客户端
+import wsock.tcp.client;
+import win.ui;
+
+namespace wsock.tcp;
+
+class asynClient{
+	ctor( hSocket ){
+		this = ..wsock.tcp.client(hSocket); 
+		this.readyState = 0;
+		
+		if(!hSocket){
+			this._form = ..win.form();
+			this._form.messageOnly();
+			this.asyncSelect(0x10/*_FD_CONNECT*/|0x1/*_FD_READ*/|0x20/*_FD_CLOSE*/|0x4/*_FD_OOB*/|0x2/*_FD_WRITE*/
+				,0xACD1/*_WM_STD_SOCKET_NOTIFY*/,this._form.hwnd)
+		
+			this._form.wndproc ={
+				[0xACD1/*_WM_STD_SOCKET_NOTIFY*/] =  function(hwnd,message,wParam,lParam){  
+					var hSocket = topointer(wParam);
+					var err,event = ::HIWORD(lParam),::LOWORD(lParam);
+					if( hSocket != this.hSocket ) return;
+	
+					select(event) {
+						case 0x10/*_FD_CONNECT*/{
+							if( !err) this.readyState = 1;
+							if( this.onConnect ) this.onConnect(err);
+						}	
+						case 0x1/*_FD_READ*/{
+							if( this.onReceive ) this.onReceive(err);
+							else if( this.onRead ) {
+								var ok,event = this.asyncSelect( this.lastSelectEvent & ~0x1/*_FD_READ*/ );
+								if(ok){
+									this.onRead(err);
+									this.asyncSelect(event);
+								};
+							};
+						} 
+						case 0x20/*_FD_CLOSE*/{
+							this.readyState = 2;
+							if( this.onClose ) this.onClose(err);
+							this.close();
+							this.readyState = 3; 
+						}
+						case 0x2/*_FD_WRITE*/{ 
+							var sendbuffer10035 = this.sendbuffer10035;
+							if(#sendbuffer10035){
+								while(#sendbuffer10035){
+									var task = sendbuffer10035[1];
+									var ret,err = this.writeBuffer(task.buffer,task.len,task.offset,task);
+									if( !ret ) {
+										this.sendbuffer10035 = {};
+										this.shutdown();
+										return;
+									}
+									if( err == 10035 ) break;
+									..table.shift(sendbuffer10035,1);
+								}
+								if( this.shuttingDown10035 !== null ){
+									..wsock.shutdown(this.hSocket,this.shuttingDown10035);
+									this.shuttingDown10035 = null;
+								}
+							} 
+							else{
+								if( this.onSend ) this.onSend(err);	
+							}
+						}
+						case 0x4/*_FD_OOB*/{
+							if( this.onOutOfBandData ) this.onOutOfBandData(err);	
+						}
+					}
+				}
+				[0x2/*_WM_DESTROY*/] = function(){
+					this.close();
+				}
+			} 
+			
+		}
+
+		this.asynTryReadTo = this.readTo;
+		
+		..table.assign(this,__asynFunction__ ); 
+	 }
+}
+
+namespace asynClient{
+    
+    __asynFunction__ = {
+		readTo = function(ends,wait){
+			var s,pendding = owner.asynTryReadTo(ends,wait);
+			
+			if(pendding){
+				owner.unRead(s);
+				return;
+			}
+			
+			if(!s){
+				owner.shutdown();	
+			}
+			return s;
+		}
+	
+		read = function(len){ 
+			if( len === null ){
+				return  owner.readTo('\r\n'); 
+			}
+			
+			if( len[["_struct"]] ){
+				var s = len;
+				var l =  ..raw.sizeof(s);
+				var p,size = owner.readAlloc(l);
+				
+				if(p){
+					var result;
+			 		if( size == l ) {
+			 			result =  ..raw.convert(p,s);
+			 		}
+			 		else {
+			 			owner.unReadAlloc(p)
+			 			return;
+			 		}
+			 		
+			 		p = ..raw.realloc(0,p);
+			 		return result;
+				}
+				
+				owner.shutdown();
+				return;
+			}
+		 	
+			var p,size = owner.readAlloc(len);
+			if(p){
+				if( len !== null ){
+					len = ..math.abs(len);
+					if( size != len ){
+						owner.unReadAlloc(p)
+						
+						if( 10035 !== ::Ws2_32.WSAGetLastError() ){ 
+							owner.shutdown();
+						}
+			 			return;
+					}
+				}
+				
+				var s = ..raw.tostring(p,1,size);
+				p = ..raw.realloc(0,p);
+				return s;	
+			} 
+			
+			owner.shutdown();
+		};
+		readBuffer = function(buffer,l){
+			if(!owner.hSocket) return null,"tcp客户端已断开";
+			
+			if(buffer){
+				var m = #buffer;
+				if( !l ) l = m;
+				elseif( l > m ) l = m;
+				elseif( l < 0 ) return;
+			}
+			
+			var p,size = owner.readAlloc(l);
+			if(p){
+				if( l!== null){
+					l = ..math.abs(l);
+					if( l!= size ){
+						owner.unReadAlloc(p)
+						
+						if( 10035 !== ::Ws2_32.WSAGetLastError() ){ 
+							owner.shutdown();
+						}
+			 			return;
+					}
+				};
+				
+				if(!buffer) {
+					buffer = ..raw.buffer(size,p);
+					p = ..raw.realloc(0,p);
+					return buffer;	
+				}
+				else {
+					..raw.copy(buffer,p,size);
+					p = ..raw.realloc(0,p);
+					return size;
+				} 
+			} 
+			else {
+				if( 10035 !== ::Ws2_32.WSAGetLastError() ){ 
+					owner.shutdown();
+				}
+			}
+		} 
+		
+		eachRead = function(remainSize){
+			var recvbuf,reads;
+			var bufSize = owner.bufferSize;
+			var hSocket = owner.hSocket;
+			var this = owner;
+			
+			return function(){
+				
+				if( remainSize !==  null ){
+					if( remainSize < bufSize ){bufSize = remainSize;}
+					if(!bufSize) return;
+				}
+				
+				var reads,recvbuf = 0;
+        		while( ( reads==0 ) && this.hSocket){
+        			reads,recvbuf = ..wsock.recv( hSocket,bufSize,bufSize,0);
+        			..win.delay(100);
+        		}
+        		
+        		if( reads>0 ) { 
+        			if( remainSize !==  null ){remainSize -= reads;}  
+					if(reads<bufSize) recvbuf = ..string.left(recvbuf,reads); 
+					return recvbuf,reads,remainSize
+				}  
+			} 
+		}; 
+		
+		eachReadBuffer = function(buffer,remainSize){
+			var recvbuf,reads;
+			var hSocket = owner.hSocket;
+			var recv = ::Ws2_32.recv;
+			var bufferSize = #buffer;
+			var this = owner; 
+			
+			return function(){
+				
+				if( remainSize !==  null ){
+					if( remainSize < bufferSize ){bufferSize = remainSize;}
+					if(!bufferSize) return;
+				}
+				
+        		var reads = 0;
+        		while( ( reads==0 ) && this.hSocket){
+        			reads = recv( hSocket,buffer,bufferSize,0);
+        			..win.delay(100);
+        		}
+        		 
+        		if( reads>0 ) { 
+        			if( remainSize !==  null ){remainSize -= reads;}   
+					return reads,remainSize
+				}  
+			} 
+		};
+	}
+}
+
+/**intellisense()
+wsock.tcp.asynClient = TCP异步客户端\n创建监听器
+wsock.tcp.asynClient(.() = 创建TCP异步客户端
+wsock.tcp.asynClient(.(套接字句柄) = 绑定异步套接字返回客户端对象\n不创建事件监听器
+wsock.tcp.asynClient() = !stdtcpaclient.
+end intellisense**/
+
+/**intellisense(!stdtcpaclient)
+readyState = 套接字连接状态,\n0为等待连接,1为已连接,2为正在关闭,3为已关闭
+isClosed() = 套接字是否已关闭
+isConnected() = 套接字是否已连接
+hSocket = 套接字句柄\n关闭对象后为空值\n此值应由对象自动维护，调用者不应修改此属性
+bufferSize = 读写缓冲区大小，默认为64KB\n缓冲区如果设置的太小，会导致过于频繁的调用读写函数
+readDelayInterval = 数据尚未到达时的等待时间\n此属性仅适用于界面线程异步套接字\n仅在所有read前缀的读数据函数中，读取长度为负值是有效,\neach前缀的迭代器函数也使用此属性指定的等待时间
+_form = 用于处理套接字消息的窗口对象\n!winform.
+getSocketError() = 获取并同时清除套接字错误代码
+connectTimeout(.(IP或域名,端口号,超时秒数) = 创建连接\n成功返回true
+bind(.(IP,端口) = 绑定IP端口
+connect(.(IP或域名,端口号) = 创建连接,\n异步套接字始终返回null，在onOpen,onErro回调事件中判断是否连接成功
+eachRead = @for(str,readSize,remainSize in ??.eachRead() ){ \n	__/*可选指在eachRead参数中指定最大长度,\n读取长度不可指定负数\n\n迭代变量:\nstr是本迭代次读取的字符串,readSize是读取的长度,	\nremainSize是剩余还没有读取的字节,	\n如果限定了最大长度,remainSize为0时才表示读完所有数据,	\n此函数不支持unRead送回的数据,\n异步客户端只能在onRead事件中使用\n\n如果套接字没有断开,并且出没有遇到错误,\n但是还没有数据到达,此函数会等待数据\n但不会阻塞消息循环*/\n} 
+eachReadBuffer = @for(readSize,remainSize in ??.eachReadBuffer() ){ \n	__/*可选指在eachReadBuffer参数中指定最大长度,\n读取长度不可指定负数\n\n迭代变量:\nreadSize是本次迭代读取的长度,buffer的实际长度可能大于readSize,	\nremainSize是剩余还没有读取的字节,	\n如果限定了最大长度,remainSize为0时才表示读完所有数据,	\n此函数不支持unRead送回的数据,\n异步客户端只能在onRead事件中使用\n\n如果套接字没有断开,并且出没有遇到错误,\n但是还没有数据到达,此函数会等待数据\n但不会阻塞消息循环*/\n} 
+readTo( = 读取直到以指定的字符串结束\n只能在onRead事件中使用\n\n此函数如果读取部分不完整数据会调用 unRead() 退回缓冲区\n读取不到任何数据会调用shutdown函数关闭连接
+readTo(.('结束串') = 读取直到以指定的字符串结束,返回值不包含结束串,\n该函数每次仅读取一个字节,效率较低\n只能在onRead事件中使用
+readTo(.('结束串',true)  = 读取直到以指定的字符串结束,返回值不包含结束串,\n如果没有读取到数据，则循环等待，等待时继续处理界面消息\n此用法仅适用于界面线程异步套接字\n该函数每次仅读取一个字节,效率较低
+read(.(读取长度) = 读取数据\n只能在onRead事件中使用\n参数可以指定长度,也可以使用接收数据的结构体作为参数\n此函数会循环读取数据，\n如果当前没有数据此函数会立即返回不会阻塞\n如果读取长度指定为负数,此函数会等待数据到达直到读取全部数据\n等待过程中不会阻塞消息循环\n不指定读取长度时表示读取一行,\n使用CRLF回车换行符分行\n\n此函数如果读取部分不完整数据会调用 unRead 函数退回缓冲区\n读取不到任何数据会调用shutdown函数关闭连接
+readAll() =  读取全部数据\n只能在onRead事件中使用
+writeBuffer(.(buffer,长度) = 发送数据,\n参数@1应使用 buffer 对象,\n可选使用参数2指定长度\n成功返回true
+readBuffer(.(buffer,读取长度) = 读取数据,返回 buffer 对象,\n省略所有参数则读取所有数据，\n参数@1可选指定一个使用 buffer 对象，\n省略读取长度时取缓冲区长度，\n\n如果参数@1指定了缓冲区,成功返回读取长度,\n否则成功返回缓冲区，\n失败返回null\n\n如果指定了长度,没有到完整的数据时,\n此函数会将数据退回缓冲区,并返回null\n如果读取出错,或没有读取到数据,此函数会自动调用shutdown关闭连接
+peek(.(长度) = 读取但并不移除缓冲区的数据,返回字符串\n不指定参数则使用bufferSize指定的大小分配buffer并尝试读取
+readOobByte() = 读取一个字节的紧急数据,返回字节码
+readAlloc( = 循环读取数据到动态指针内,\n对于异步套接字，只能在onRead函数内使用此函数,\n动态指针的使用风险较大,如果不是非常熟悉其规则,\n建议不要使用此函数\n\n对象所有read前缀的成员函数底层基本都是调用这个函数\n此函数读取的数据支持调用unRead或unReadAlloc,\n撤消并退回到读缓冲区
+readAlloc(.() = 循环读取数据，直到读取结束,
+readAlloc(.(读取长度) = 循环读取数据，直到达到参数中限定的最大长度\n无数据返回null，\n\n如果读取到数据则返回2个值：动态指针,内存长度\n调用者必须负责调用 raw.realloc(0,动态指针)\n释放返回值1返回的指针\n\n此函数直接操作内存，效率更好\n但一定要记住释放返回的内存指针
+readAlloc(.(动态指针) =  循环读取数据并存入参数指定的动态指针,\n返回新的指针地址和内存长度,\n此函数可能更新指针地址或分配的内存大小，\n必须使用返回的新指针覆盖原来保存该动态指针的变量值
+unReadAlloc(__) = 把readAlloc读取的动态指针退回缓存,\n\n注意退回数据的顺序是“后出先进”，\n最后读出的应当最先退回
+unRead(__) = 把read,readTo,readBuffer等函数读出的数据退回缓存，\n注意退回数据的顺序是“后出先进”，\n最后读出的应当最先退回
+write(.(->->->) = 发送数据,\n支持一个或多个参数，参数支持字符串、buffer (buffer)、数值、结构体\n成功返回true
+close() = 关闭TCP客户端\n如果未显式调用此函数\n在对象析构时,将会自动调用
+shutdown(__) = 断开连接,\n参数中指定0为仅停止收数据,指定1为停止发数据\n默认值为2表示停止收发数据\n此函数并不销毁套接字句柄,也不会关闭事件监听器
+setTimeouts(.(发送超时,接收超时) = 设置超时,以亳秒为单位(1秒为1000毫秒)
+getLocalIp() = 返回连接的本地IP,端口号
+getRemoteIp() = 返回连接的远程IP,端口号
+asyncSelect(.(event) = 检测到由event参数指明的网络事件后,\n参数@1使用_FD_前缀的常量指定,可使用位或操作符指定多个选项\n事件到达会触发相应的事件(参考on前缀的事件函数),\n\n失败返回null,以及错误信息,\n成功返回true,以及上次调用此函数指定的event参数
+lastSelectMessageId = 最后一次调用asyncSelect应用的消息ID\n不可手动修改此属性，应由对象自动维护
+lastSelectHwnd = 最后一次调用asyncSelect应用的窗口句柄\n不可手动修改此属性，应由对象自动维护
+lastSelectEvent = 最后一次调用asyncSelect应用的事件\n不可手动修改此属性，应由对象自动维护
+recv(.(最大接收长度) = 单次接收数据包\n如果参数不指定长度，则使用bufferSize指定的长度\n成功返回字符串,\n失败返回null,错误代码\n\nrecv,recvBuffer应在onReceive事件中使用，\n在onReceive里不能多次调用recv,recvBuffer。\nrecv,recvBuffer不保证每次一定会读完数据，所以在onClose事件里要继续读到没有任何数据。\n\n在 onRead事件中调用read前缀的系列函数可以循环读取所有接收的数据，\n这样就可以避免onClose以后还数据没有收完的问题
+recvBuffer(.(缓冲区,读取长度) = 单次接收数据包\n参数@1指定 buffer 对象,\n参数@2可省略,默认为缓冲区长度,\n成功返回接收的长度,\n失败返回null,错误代码\n\nrecv,recvBuffer应在onReceive事件中使用，\n在onReceive里不能多次调用recv,recvBuffer。\nrecv,recvBuffer不保证每次一定会读完数据，所以在onClose事件里要继续读到没有任何数据。\n\n在 onRead事件中调用read前缀的系列函数可以循环读取所有接收的数据，\n这样就可以避免onClose以后还数据没有收完的问题
+send(.(数据,长度) = 单次发送数据包
+flush() = 兼容aardio标准流接口
+setopt(_SO__) = 设置选项\n参数@1使用_SO_前缀的常量指定选项,参数@2使用结构体或数值指定值\n可选用参数@3指定设置层次，默认为SOL_SOCKET\n成功返回true
+getopt(_SO__) = 获取选项\n参数@1使用_SO_前缀的常量指定选项,参数@2使用结构体指定值\n如果不指定参数@2,则获取一个32位整型数值,\n可选用参数@3指定设置层次，默认为SOL_SOCKET\n成功返回读取的结构体
+onConnect = @.onConnect = function(err){
+	__/*连接操作已完成,\n连接成功时err为0，且readyState为1,\n在这里可以开始发送数据*/	
+}
+onReceive = @.onReceive = function(err){
+	__/*收到数据,\n仅读取已到达的数据,\n定义了此事件就不应同时定义onRead事件*/	
+}
+onRead = @.onRead = function(err){
+	__/*收到数据,\n可阻塞读取数据,\n定义了此事件就不应同时定义onReceive事件*/	
+}
+onOutOfBandData = @.onOutOfBandData = function(err){
+	__/*收到紧急数据,\n即send函数最后一个flag参数设为_MSG_OOB时发送的1字节带外数据*/		
+}
+onSend = @.onSend = function(err){
+	__/*发送数据*/
+}
+onClose = @.onClose = function(err){
+	__/*已断开连接,\n如果缓冲区中仍然有数据,\n这个事件可能在其他事件前面触发*/	
+}	
+end intellisense**/