网络通讯 ​

IF bInit THEN 
   bInit := FALSE;
   
   hSocketListen := -1;

  (* 初始化客户端信息 *)
   FOR i := 0 TO iNumMaxClient BY 1 DO 
    arrClient[i].hClientSocket := -1;
    arrClient[i].dwRecvTime := 0;
    arrClient[i].dwIP := 0;
    arrClient[i].strIP := '';
  END_FOR;
   
   bServerSetup := TRUE;
END_IF;

(* 启动服务器 *)
IF bServerSetup THEN 
   bServerSetup := FALSE;

   hSocketListen := Socket( socket_family , socket_type , socket_protocol);
   IF hSocketListen >= 0 THEN 
     (* 关闭时TCP将丢弃保留在套接口发送缓冲区中的任何数据并发送一个RST给对方，而不是通常的四分组终止序列，这避免了TIME_WAIT状态 *)
     so_linger.l_onoff := 1;
     so_linger.l_linger := 0;
     iOprRet := SocketSetOption( hSocketListen , SOCKET_SOL , SOCKET_SO_LINGER , ADR(so_linger) , SIZEOF(so_linger) );

​     iOptValue := 1;
​     (* 设置为可重复使用地址 *)
​     iOprRet := SocketSetOption( hSocketListen , SOCKET_SOL , SOCKET_SO_REUSEADDR , ADR(iOptValue) , SIZEOF(iOptValue) );
​     (* 开启Nagle算法 *)
​     iOprRet := SocketSetOption( hSocketListen , SOCKET_IPPROTO_TCP , SOCKET_TCP_NODELAY , ADR(iOptValue) , SIZEOF(iOptValue) );

​     (* 设置socket的发送、接收缓存 *)
​     dwSocketBuffSize := 32*1024;
​     iOprRet := SocketSetOption( hSocketListen , SOCKET_SOL , SOCKET_SO_SNDBUF , ADR(dwSocketBuffSize) , SIZEOF(dwSocketBuffSize) );
​     iOprRet := SocketSetOption( hSocketListen , SOCKET_SOL , SOCKET_SO_RCVBUF , ADR(dwSocketBuffSize) , SIZEOF(dwSocketBuffSize) );

​     (* 设置为非阻塞 *)
​     iOprRet := SocketIoctl( hSocketListen , SOCKET_FIONBIO , ADR(iOptValue) );

​     (* 绑定监听端口 *)
​     SockAddrServer.sin_addr.addr := SocketHtonl( dwServerIpAddr );
​     SockAddrServer.sin_family := SOCKET_AF_INET;
​     SockAddrServer.sin_port := SocketHtons( wServerPort );
​     iOprRet := SocketBind( hSocketListen , ADR(SockAddrServer) , SIZEOF(SockAddrServer) );
​     IF 0 = iOprRet THEN 
​       (* 监听 *)
​       iOprRet := SocketListen( hSocketListen , iNumMaxClient );
​       IF 0 = iOprRet THEN 
​         SocketFdZero( ADR(FdSet) );
​         SocketFdSet( hSocketListen , ADR(FdSet) );
​         IF hSocketListen > maxFd THEN 
​           maxFd := hSocketListen;
​         END_IF;
​       ELSE
​         (* 监听失败则关闭创建的socket *)
​         SocketClose( hSocketListen );
​         hSocketListen := -1;
​       END_IF;
​     ELSE
​       (* 绑定失败则关闭创建的socket *)
​       SocketClose( hSocketListen );
​       hSocketListen := -1;
​     END_IF;
   END_IF;
END_IF;

(* 数据接收处理 *)
IF hSocketListen >= 0 THEN 
   tmSlect.tv_sec := 0;
   tmSlect.tv_usec := 10000;
   FdSetRun := FdSet;
   diReady := SocketSelect( maxFd + 1 , ADR(FdSetRun) , pSetTemp , pSetTemp , ADR(tmSlect) );
   IF diReady > 0 THEN 
     (* 新的连接请求 *)
     IF SocketFdIsSet( hSocketListen , ADR(FdSetRun) ) THEN
       hClientSocket := SocketAccept( hSocketListen , ADR(stClientAddress) , ADR(diClientAddressLen) );
       FOR i := 0 TO iNumMaxClient BY 1 DO 
         IF -1 = arrClient[i].hClientSocket THEN 
           arrClient[i].hClientSocket := hClientSocket;
           arrClient[i].dwRecvTime := GetTickCount();
           arrClient[i].dwIP := stClientAddress.sin_addr.addr;
           SocketInetNtoa( ADR(arrClient[i].dwIP) , ADR(arrClient[i].strIP) , SIZEOF(arrClient[i].strIP) );
           EXIT;
         END_IF;
       END_FOR;

​       (* 将新的连接句柄添加到集合中 *)
​       SocketFdSet( hClientSocket , ADR(FdSet) );
​       IF hClientSocket > maxFd THEN 
​         maxFd := hClientSocket;
​       END_IF;
​     END_IF;

​     (* 客户端连接数据到达 *)
​     FOR i := 0 TO iNumMaxClient BY 1 DO 
​       IF arrClient[i].hClientSocket >= 0 THEN 
​         IF SocketFdIsSet( arrClient[i].hClientSocket , ADR(FdSetRun) ) THEN
​           diRecvLen := SocketRecv( arrClient[i].hClientSocket , ADR(arrDataRecv) , SIZEOF(arrDataRecv) , 0 );
​           IF diRecvLen > 0 THEN 
​             arrClient[i].dwRecvTime := GetTickCount();
​             
​             (* 将接收到的数据原封不动的返回 *)
​             diSendLen := SocketSend( arrClient[i].hClientSocket , ADR(arrDataRecv) , diRecvLen , 0 );
​             IF diSendLen > 0 THEN 
​               dwSendTotalLen := dwSendTotalLen + diSendLen;
​             END_IF;
​             dwRecvTotalLen := dwRecvTotalLen + diRecvLen;
​           END_IF;
​         END_IF;
​       END_IF;
​     END_FOR;
   END_IF;

   (* 超时检测 *)
   FOR i := 0 TO iNumMaxClient BY 1 DO 
     IF arrClient[i].hClientSocket >= 0 THEN 
       dwTime := GetTickCount();
       dwTime := dwTime - arrClient[i].dwRecvTime;
       IF dwTime > dwTimeout THEN 
         (* 关闭客户端连接，并将客户端连接句柄从集合中移除 *)
         SocketFdClr( arrClient[i].hClientSocket , ADR(FdSet) );
         SocketClose( arrClient[i].hClientSocket );
         arrClient[i].hClientSocket := -1;
         arrClient[i].dwRecvTime := 0;
         arrClient[i].dwIP := 0;
         arrClient[i].strIP := '';
       END_IF;
     END_IF;
   END_FOR;
END_IF;

(* 关闭服务器 *)
IF bServerClose THEN 
   bServerClose := FALSE;

   (* 将监听句柄从集合中移除 *)
   SocketFdClr( hSocketListen , ADR(FdSet) );
   SocketClose(hSocketListen);
   hSocketListen := -1;

   (* 将客户端连接句柄从集合中移除 *)
   FOR i := 0 TO iNumMaxClient BY 1 DO 
     IF arrClient[i].hClientSocket >= 0 THEN 
       SocketFdClr( arrClient[i].hClientSocket , ADR(FdSet) );
       SocketClose( arrClient[i].hClientSocket );
       arrClient[i].hClientSocket := -1;
       arrClient[i].dwRecvTime := 0;
       arrClient[i].dwIP := 0;
       arrClient[i].strIP := '';
     END_IF;
   END_FOR;
END_IF;

IF bInit THEN 
    bInit := FALSE;

    hSocket := -1;
    bClientSetup := TRUE;
END_IF;

(* 创建一个客户端，并连接到服务器 *)
IF bClientSetup THEN 
    bClientSetup := FALSE;

    hSocket := Socket( socket_family , socket_type , socket_protocol);
    IF hSocket >= 0 THEN 
        (* 设置为阻塞模式 *)
        iOptValue := 0;
        iOprRet := SocketIoctl( hSocket , SOCKET_FIONBIO , ADR(iOptValue) );

        (* 连接到服务器 *)
        iOprRet := SocketInetAddr( ADR(strRemoteIP) , ADR(dwRemoteIP) );
        IF 0 = iOprRet THEN 
            SockAddrClient.sin_family := SOCKET_AF_INET;
            SockAddrClient.sin_port := SocketHtons( wServerPort );
            SockAddrClient.sin_addr.addr := dwRemoteIP;
            iOprRet := SocketConnect( hSocket , ADR(SockAddrClient) , SIZEOF(SockAddrClient) );
            IF 0 = iOprRet THEN 
                SocketFdZero( ADR(FdSet) );
                SocketFdSet( hSocket , ADR(FdSet) );
                IF hSocket > maxFd THEN 
                    maxFd := hSocket;
                END_IF;
            ELSE
                (* 连接失败则关闭创建的socket *)
                SocketClose( hSocket );
                hSocket := -1;
            END_IF;
        END_IF;
    END_IF;
END_IF;

(* 发送数据，并启动接收 *)
IF bSend THEN 
    bSend := FALSE;

    IF hSocket >= 0 THEN 
        diSendLen := SocketSend( hSocket , ADR(arrDataSend) , dwExpectSendLen , 0 );
        IF diSendLen > 0 THEN 
            dwSendTotalLen := dwSendTotalLen + diSendLen;
            bRecv := TRUE; //成功发送数据后 则启动接收
        END_IF;
    END_IF;
END_IF;

(* 接收数据，接收到数据后停止接收 *)
IF bRecv THEN 
    IF hSocket >= 0 THEN 
        tmSlect.tv_sec := 0;
        tmSlect.tv_usec := 10000;
        FdSetRun := FdSet;
        diReady := SocketSelect( maxFd + 1 , ADR(FdSetRun) , pSetTemp , pSetTemp , ADR(tmSlect) );
        IF diReady > 0 THEN 
            IF SocketFdIsSet( hSocket , ADR(FdSetRun) ) THEN
                diRecvLen := SocketRecv( hSocket , ADR(arrDataRecv) , SIZEOF(arrDataRecv) , 0 );
                IF diRecvLen > 0 THEN 
                    dwRecvTotalLen := dwRecvTotalLen + diRecvLen;
                    bRecv := FALSE;
                END_IF;
            END_IF;
        END_IF;
    END_IF;
END_IF;

(* 关闭一个客户端 *)
IF bClientClose THEN 
    bClientClose := FALSE;

    IF hSocket >= 0 THEN 
        (* 关闭socket，并将socket句柄从集合中移除 *)
        SocketFdClr( hSocket , ADR(FdSet) );
        SocketClose( hSocket );
        hSocket := -1;
    END_IF;
END_IF;

IF bInit THEN 
   bInit := FALSE;
   
   hSocket := -1;
   bServerSetup := TRUE;
END_IF;

(* 启动服务器 *)
IF bServerSetup THEN 
   bServerSetup := FALSE;

   hSocket := Socket( socket_family , socket_type , socket_protocol);
   IF hSocket >= 0 THEN 
     diOptValue := 1;
     iOprRet := SocketSetOption( hSocket, SOCKET_SOL, SOCKET_SO_REUSEADDR, ADR(diOptValue), SIZEOF(diOptValue));

​     ServerSockAddr.sin_addr.addr := SOCKET_INADDR_ANY;
​     ServerSockAddr.sin_family := socket_family;
​     ServerSockAddr.sin_port := SocketHtons( wServerPort );
​     iOprRet := SocketBind( hSocket , ADR(ServerSockAddr) , SIZEOF(ServerSockAddr));
​     IF 0 = iOprRet THEN 
​       SocketFdZero( ADR(FdSet) );
​       SocketFdSet( hSocket , ADR(FdSet) );
​       IF hSocket > maxFd THEN 
​         maxFd := hSocket;
​       END_IF;
​     ELSE
​       SocketClose( hSocket );
​       hSocket := -1;
​     END_IF;
   END_IF;
   
END_IF;

(* 数据接收处理 *)
IF hSocket >= 0 THEN 
   tmSlect.tv_sec := 0;
   tmSlect.tv_usec := 10000;
   FdSetRun := FdSet;
   diReady := SocketSelect( maxFd + 1 , ADR(FdSetRun) , pSetTemp , pSetTemp , ADR(tmSlect) );
   IF diReady > 0 THEN 
     IF SocketFdIsSet( hSocket , ADR(FdSetRun) ) THEN
       diRecvedLen := SocketRecvfrom( hSocket , ADR(arrRecv) , SIZEOF(arrRecv) , dwFlags , ADR(SockAddrRecv), ADR(diSockAddrSize));
       IF diRecvedLen > 0 THEN 
         dwRecvedTotalLen := dwRecvedTotalLen + diRecvedLen;

​         (* 将接收到的数据原封不动的返回 *)
​         SockAddrSend.sin_addr.addr := SockAddrRecv.sin_addr.addr;
​         SockAddrSend.sin_family := SOCKET_AF_INET;
​         SockAddrSend.sin_port := SockAddrRecv.sin_port;
​         diSentLen := SocketSendto( hSocket , ADR(arrRecv) , diRecvedLen , dwFlags , ADR(SockAddrSend) , SIZEOF(SockAddrSend));
​         IF diSentLen > 0 THEN 
​           dwSentTotalLen := dwSentTotalLen + diSentLen;
​         ELSE
​           diLastError := GetLastError();
​         END_IF;
​       END_IF;
​     END_IF;
   END_IF;
END_IF;

(* 关闭服务器 *)
IF bServerClose THEN 
   bServerClose := FALSE;
   SocketFdClr( hSocket , ADR(FdSet) );
   SocketClose( hSocket );
   hSocket := -1;
END_IF;