socket的客户端编码如何知道数据发送来了呢？

Question

网上很多例子都是将服务器端的，好像客户端讲的比较少比如，我现在要用socket api，不用csocket,在建立连接后，如何知道数据发送过来了呢？要用recv一直在哪里接受吗？

Answer 1

SOCKET sockSvr, sockCli;DWORD listenProc(LPVOID lparam);
DWORD readProc(LPVOID lparam);void main()
{
    WSADATA wsadata;
    sockaddr_in saddr;
    int err=WSAStartup(MAKEWORD(2, 2), &wsadata);
    if(err != 0) {
        return FALSE;
    }
    sockSvr = socket(PF_INET, SOCK_STREAM, 0);
    if(sockSvr == INVALID_SOCKET) {
        return FALSE;
    }
    memset(&saddr, 0, sizeof(sockaddr_in));
    saddr.sin_family = PF_INET;
    saddr.sin_port=htons(8000);e
    err = bind(sockSvr, (SOCKADDR *)&saddr, sizeof(SOCKADDR));
    if(err != 0) {
        return FALSE;
    }
    err = listen(sockSvr, 5);
    while(1){
        cliSock = accept(tmpsock, NULL, NULL);
        if(sockCli != INVALID_SOCKET) {
            CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)readProc, (void *)sockCli, 0, NULL);
        }
    }
    return 0;
}DWORD readProc(LPVOID lparam)
{
    char buf[100];
    char *tmpdata;
    int readlen, datalen = 100;
    SOCKET cliSock = (SOCKET)lparam;
    while(1) {
        readlen = recv(cliSock, buf, datalen, 0);
        buf[readlen] = '\0';
        printf("%s\n", buf);    }
    return ;
}
client端：SOCKET sockCli;
DWORD recvProc(LPVOID lparam)
{
    char buf[100];
    int recvlen;
    while(1) {
        recvlen = recv(sockCli, buf, 100, 0);
        if(recvlen <= 0) {
            closesocket(sockCli);
            break;
        }
        buf[recvlen] = 0;
        printf("%s\r\n", buf);
    }
    return 0;
}void main()
{
    WSADATA wsadata;
    sockaddr_in saddr;
    int err=WSAStartup(MAKEWORD(2, 2), &wsadata);
    if(err != 0) {
        return FALSE;
    }
    sockCli = socket(PF_INET, SOCK_STREAM, 0);
    if(sockCli == INVALID_SOCKET) {
        return FALSE;
    }
    
    memset(&saddr, 0, sizeof(sockaddr_in));
    saddr.sin_family = PF_INET;
    saddr.sin_port=htons(8000);
    saddr.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");//
    if(connect(sockCli, (SOCKADDR*)&saddr, sizeof(SOCKADDR))==0) {
        CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)recvProc, NULL, 0, NULL);
    } 
        
        while(1) {
                 if(send(sockCli, "Hello World!", 12,0) <= 0){ //不断地发送hello world
                          closesocket(sockCli);
                  }
                  sleep(100);
        }       
}源码， socket通信有两种模式， 一种是同步模式，也就是说，在执行recv时，程序会阻塞在这里，直到有数据过来才返回，另一种异步模式， 就是有数据过来时， 系统会发消息通知你，或者你自己去检测

Answer 2

可以先select一下看看有没有数据来

Answer 3

#include "../common/initsock.h"
#include <stdio.h>CInitSock theSock;        // 初始化Winsock库
int main()
{
    USHORT nPort = 4567;    // 此服务器监听的端口号    // 创建监听套节字
    SOCKET sListen = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);    
    sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_port = htons(nPort);
    sin.sin_addr.S_un.S_addr = INADDR_ANY;
    // 绑定套节字到本地机器
    if(::bind(sListen, (sockaddr*)&sin, sizeof(sin)) == SOCKET_ERROR)
    {
        printf(" Failed bind() \n");
        return -1;
    }
    // 进入监听模式
    ::listen(sListen, 5);        // select模型处理过程
    // 1）初始化一个套节字集合fdSocket，添加监听套节字句柄到这个集合
    fd_set fdSocket;        // 所有可用套节字集合
    FD_ZERO(&fdSocket);
    FD_SET(sListen, &fdSocket);
    while(TRUE)
    {
        // 2）将fdSocket集合的一个拷贝fdRead传递给select函数，
        // 当有事件发生时，select函数移除fdRead集合中没有未决I/O操作的套节字句柄，然后返回。
        fd_set fdRead = fdSocket;
        int nRet = ::select(0, &fdRead, NULL, NULL, NULL);
        if(nRet > 0)
        {
            // 3）通过将原来fdSocket集合与select处理过的fdRead集合比较，
            // 确定都有哪些套节字有未决I/O，并进一步处理这些I/O。
            for(int i=0; i<(int)fdSocket.fd_count; i++)
            {
                if(FD_ISSET(fdSocket.fd_array[i], &fdRead))
                {
                    if(fdSocket.fd_array[i] == sListen)        // （1）监听套节字接收到新连接
                    {
                        if(fdSocket.fd_count < FD_SETSIZE)
                        {
                            sockaddr_in addrRemote;
                            int nAddrLen = sizeof(addrRemote);
                            SOCKET sNew = ::accept(sListen, (SOCKADDR*)&addrRemote, &nAddrLen);
                            FD_SET(sNew, &fdSocket);
                            printf("接收到连接（%s）\n", ::inet_ntoa(addrRemote.sin_addr));
                        }
                        else
                        {
                            printf(" Too much connections! \n");
                            continue;
                        }
                    }
                    else
                    {
                        char szText[256];
                        int nRecv = ::recv(fdSocket.fd_array[i], szText, strlen(szText), 0);
                        if(nRecv > 0)                        // （2）可读
                        {
                            szText[nRecv] = '\0';
                            printf("接收到数据：%s \n", szText);
                        }
                        else                                // （3）连接关闭、重启或者中断
                        {
                            ::closesocket(fdSocket.fd_array[i]);
                            FD_CLR(fdSocket.fd_array[i], &fdSocket);
                        }
                    }
                }
            }
        }
        else
        {
            printf(" Failed select() \n");
            break;
        }
    }
    return 0;
}
以上是select模型服务器端代码根据select函数的返回值判断有数据的到来

Answer 4

看看socket IO模型select，WSAAsyncSelect，WSAEventSelect，Overlapped IO，IOCP

Answer 5

如果不是用csocket类，是不是需要另外开一个线程，不停的select来获取socket的状态？

Answer 6

select 有时在设置缓冲区大小时不好使

Answer 7

while循环。。都是这样做的，客户端又不是服务器 可以不用考虑性能问题！

Answer 8

如果是Windows窗口程序可以使用WSAAsyncSelect
如果是Console程序可以使用select WSAEventSelect
也可以使用重叠IO

Answer 9

用异步socket和select模型就可以实现了！

Answer 10

在MFC可以定义一个消息映射函数，当消息到达的时候会收到一个READ的消息，直接用recv/recvfrom进行接收
首先创建一个socket
SOCKET m_hSocket;
m_hSocket = socket(AF_INET,SOCK_STREAM/SOCK_DGRAM,0);
bind()
然后在定义一个消息
#define WM_MSGBOX WM_USER+100
然后在消息映射中定义
ON_MESSAGE(WM_MSGBOX,OnReceive)
定义一个OnReveive函数
afx_msg void OnReceive(WPARAM wParam,LPARAM lParam);
再实现OnReceive()
void CDialog::OnReceive(WPARAM wParam,LPARAM lParam)
{
   switch(lParam)
  {
    case FD_READ:
       recv(buff,sizeof(buff),0);
  }
}
以上只是简要介绍了下，切勿复制粘贴~