利用流式套接字传输数据文件

服务器端：
1>建立一个基于对话框的应用程序StreamSocketServer
2>设计界面，将“确定”按钮的标题改为“启动”
3>双击“启动按钮”，添加以下代码，初始化网络，启动服务器监听

void CStreamSocketServerDlg::OnOK() 
{
    // TODO: Add extra validation here
    WSADATA wsaData;
    /*
    typedef struct WSAData
    {
        WORD wVersion;  //为希望使用的Winsock版本
        WORD wHeighVersion;  //返回现有的Winsock库的最高版本
        char szDescription[WSADESCRIPTION_LEN+1];  //通常不用
        char szSystemStatus[WSASYS_STATUE_LEN+1];  //通常不用
        unsigned short iMaxSockets;  //可同时打开的套接字数
        unsigend short iMaxUdpDg;    //数据报最大长度
        char FAR * lpVendorInfo;   //为制定Winsock实施方案的厂商信息所预留，在任何一个Win32平

台上都没有使用这个字段]
    }
    */

    //初始化TCP协议
    BOOL ret = WSAStartup(MAKEWORD(2, 2), &wsaData);
    /*
    int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);
    wVersionRequested 用户制定准备加载的Winsock库的版本.
    宏定义MAKEWOARD(X, Y) 获得wVersionRequested的正确值, [X为高位字节，Y为低位字节, 
    lpWSAData 为指向LPWSDATA结构的指针，包含了加载库版本有关的信息
    */
    if(ret != 0)
    {
        MessageBox("初始化网络协议失败！");
        return;
    }

    //创建服务器端套接字
    ServerSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    /*
    SOCKET socket(int af, int type, int protocol);
    af用于制定网络类型，一般取AF_INET，表示该套接字在Internet域中进行通信
    type用于指定套接字类型，SOCK_STREAM表示流套接字, SOCK_DGRAM表示数据报套接字
    protocol用于指定网络协议，默认为0，表示TCP/IP协议
    */
    if(ServerSock == INVALID_SOCKET)
    {
        MessageBox("创建失败！");
        closesocket(ServerSock);   
    }

    //绑定到本地一个端口上
    sockaddr_in localaddr;
    /*
    struct sockaddr_in
    {
        short sin_family;   //必须为AF_INET，表示该socket处于Internet域
        u_short sin_port;   //用于指定服务端口
        struct in_addr sin_addr;  //把一个IP地址保存为一个4字节的数，其数据类型为无符号长整数

类型
        char sin_zero[8];    //只充当填充项角色，使得与sockaddr长度保持一致
    }
    */
    localaddr.sin_family = AF_INET;
    localaddr.sin_port = htons(6000);  
    /*
    htons的功能:将一个无符号短整型的主机数值转换为网络字节顺序，即大尾顺序(big-endian)
    参数u_short hostshort:16位无符号整数
    返回值:TCP/IP网络字节顺序.
    */
    localaddr.sin_addr.s_addr = 0;
    if(bind(ServerSock, (struct sockaddr *)&localaddr, sizeof(sockaddr)) == SOCKET_ERROR)
    {
        MessageBox("绑定地址失败！");
        closesocket(ServerSock);
        WSACleanup();
        return;
    }
    /*
    int bind(SOCKET s, const struct sockaddr FAR *name, int namelen);
    s标识一个未捆绑套接字的句柄，用来等待客户机的连接
    name是赋予套接字的地址
    */

    //将ServerSock设置为异步非阻塞模式，并为它注册各种网络异步事件 
    //m_hWnd为应用程序的主对话框或主窗口的句柄
    if(WSAAsyncSelect(ServerSock, m_hWnd, NETWORK_EVENT, FD_ACCEPT|FD_CLOSE|FD_READ|FD_WRITE) == 

SOCKET_ERROR)
    {
        MessageBox("注册失败！");
        WSACleanup();
        return;
    }
    /*
    int WSAAsyncSelect(
        SOCKET s,    
        HWND hWnd,   //接收消息的窗口句柄
        unsigned int wMsg;  //网络事件发生时要接收的消息
        long lEvent;   //被注册的网络事件
    );
    lEvent参数值及意义：
    FD_READ  希望在套接字s收到数据时收到消息
    FD_WRITE 希望在套接字s可以发送数据时收到消息
    FD_ACCEPT 希望在套接字s收到连接请求是收到消息
    FD_CONNECT  希望在套接字s连接成功是收到消息
    FD_CLOSE 希望在套接字s连接关闭是收到消息
    FD_OOB 希望在套接字s收到外带数据时收到消息

    NETWORK_EVENT 为自定义消息，并添加其响应处理函数OnNetEvent(WPARAM wParam, LPRAM lParam)
     */

    listen(ServerSock, 31); //设置为侦听模式，最多要31个连接
    MessageBox("服务启动成功！");
    CDialog::OnOK();
}

4>注册自定义消息NETWORK_EVENT, 并添加其相应处理函数OnNetEvent

在StreamSocketServerDlg.h中添加成员函数：

void OnNetEvent(WPARAM wParam, LPARAM lParam);

在StreamSocketServerDlg.cpp中实现：

void CStreamSocketServerDlg::OnNetEvent(WPARAM wParam, LPARAM lParam)
{
    int iEvent = WSAGETSELECTEVENT(lParam); //调用Winsock API函数，得到网络事件类型
    SOCKET CurSock = (SOCKET)wParam;  //调用Winsock API函数，得到此事件的客户端套接字
    switch(iEvent)
    {
    case FD_ACCEPT:  //客户端连接请求事件
        TRACE("Get client call!\n");
        OnAccept(CurSock); 
        break;
    case FD_CLOSE:   //客户端断开事件
        OnClose(CurSock);
        break;
    case FD_READ:   //客户端网络包到达事件
        OnReceive(CurSock);
        break;
    case FD_WRITE:  //发送网络数据事件
        break;
    default: break;
    }
}

5>添加客户端的连接请求处理函数

void CStreamSocketServerDlg::OnAccept(SOCKET CurSock)
{
    SOCKET TempSock;
    struct socaaddr_in ConSocketAddr;
    int addrlen;
    addrlen = sizeof(ConSocketAddr);
    TempSock = accept(CurSock, (struct sockaddr*)&ConSocketAddr, &addrlen);
    /*
    用于接受连接请求
    SCOKET accept(
        SCOKET s,   //Socket的识别码
        struct sockaddr FAR * addr,  //存放连接的客户端地址
        int FAR* addrlen  //地址长度
    )
    */
    if(ConnectSock == INVALID_SOCKET)
        MessageBox("INVALID_SOCKET");
    TRACE("建立新连接，sock:%d\n", TempSock);  //输出调试信息
    inet_ntoa(ConSocketAddr.sin_addr);
    ConnectSock = TempSock;
    char *filename = "c:\\001.doc";
    if(!SendFile(filename, ConnectSock))
        MessageBox("发送失败！");

}

6>添加发送数据文件函数

BOOL CStreamSocketServerDlg::SendFile(char *name, SOCKET conn)
{
    char *FileName = name;
    SOCKET TcpConn = conn;
    CFile file;
    if(!file.Open(FileName, CFile::modeRead))
    {
        printf("打开%s失败！\n", FileName);
        return FALSE;
    }
    int NumBytes;  //用来保存每次传送时数据块的大小
    UINT Total = 0;  //用来保存套接字已经传送的总的字节数
    int BufSize = 1024;  //发送缓冲区的大小
    int Size = BufSize;  //读取文件的大小
    LPBYTE pBuf = new BYTE[BufSize];  //发送缓冲区
    DWORD dwTemp = 0;
    UINT FileLength = file.GetLength();  //得到文件的大小并发送出去
    send(TcpConn, (char *)&FileLength, 4, 0);
    /*
    int send(  //返回发送的字符总数
        SOCKET s,
        const char FAR *buf,  //存放要传送的资料的暂存区
        int len,  //buf的长度
        int flags   //此函数被调用的方式
    )
    */
    file.SeekToBegin();
    while(Total < FileLength)
    {
        if((int)(FileLength - Total) < Size)
            Size = FileLength - Total;
        Size = file.Read(pBuf, Size);
        /*
        virtual UINT Read(
            void* lpBuf,  //是把资源读入哪里
            UINT nCount   //是读入的字节数
        );
        */
        NumBytes = send(TcpConn, (char *)pBuf, Size, 0);
        if(NumBytes == SOCKET_ERROR)
        {
            send(TcpConn, "ERROR", sizeof("ERROR")+1, 0);
            return FALSE;
        }
        Total += NumBytes;
        file.Seek(Total, CFile::begin);
    }
    delete[] pBuf;
    file.Close();
    closesocket(TcpConn);
    return TRUE;
}

客户端：
1>新建一个基于对话框的程序StreamSocketClient
2>设计界面，添加编辑框m_CtrlPAddress输入IP地址，m_iPort用于输入端口，将“确定”按钮改为“连接”，“取消”改为“关闭”
3>双击“连接”，添加以下代码：

void CStreamSocketClientDlg::OnOK() 
{
    // TODO: Add extra validation here
    UpdateData(FALSE);  //初始化对话框中的数据
    WORD wVersionRequested;
    WSADATA wsaData;
    int err;
    wVersionRequested = MAKEWORD(2, 2);  //连接两个给定的无符号参数
    err = WSAStartUp(wVersionReqested, &wsaData);
    if(err != 0)
        return;
    if(LOBYTE(wsaData.wVersion) != 1) || HIBYTE(wsaData.wVersion) != 1) //LOBYTE()得到一个16bit数

最低(最右边)那个字节
    {
        WSACleanup();
        return;
    }
    SOCKET TcpClient = socket(AF_INET, SOCK_STREAM, 0);
    SOCKADDR_IN SerAddr;
    SerAddr.sin_family AF_INET;
    SerAddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    /*
    struct in_addr{
        union{
            struct{ u_char s_b1, s_b2, s_b3, s_b4;} S_un_b;
            struct{u_short S_w1, S_w2} S_un_w;
            u_long S_addr;
        }S_un;
    };
    */
    SerAddr.sin_port = htos(m_iPort);
    connect(TcpClient, (SOCKADDR*)&SerAddr, sizeof(SerAddr));  //与服务器端建立连接
    /*
    int connect(
        SOCKET s,  //服务器端Socket的识别码
        const struct sockaddr FAR* name,  //Socket想要连接的对方地址
        int namelen  //地址长度
    )
    */
    long FileLength;
    recv(TcpClient, (char *)&FileLength, sizeof(long), 0);
    /*
    int recv(
        SOCKET s,   
        char FAR *buf,   //存放接收到资料的暂存区
        int len,    //buf的长度
        int flags   //此函数的调用方式
    )
    */
    if(RecvFile("c:\\003.doc", TcpClient, FileLength))
        MessageBox("传输结束！\n");
    else
        MessageBox("传输失败！\n");
    CDialog::OnOK();
}

4>添加接收文件函数

BOOL CStreamSocketClientDlg::RecvFile(char *name, SOCKET conn, UINT filelen)
{
    char *FileName = name;
    SOCKET client = conn;
    CFile file;
    if(!file.Open(FileName, CFile::modeWrite))
    {
        printf("打开%s失败！\n", FileName);
        return FALSE;
    }
    int NumBytes;  //用来保存每次接收时数据块的大小
    UINT Total = 0;  //用来保存套接字已经接收的总的字节数
    int BufSize = 1024;  //接收缓冲区的大小
    int Size = BufSize;  //写文件的大小
    LPBYTE pBuf = new BYTE[BufSize];  //接收缓冲区
    DWORD dwTemp = 0;
    file.SeekToBegin();
    while(Total < filelen)
    {
        if((int)(filelen - Total) < Size)
            Size = filelen - Total;
        NumBytes = recv(client, (char *)pBuf, Size, 0);

        if(NumBytes == SOCKET_ERROR)
        {
            printf("接收失败！\n");
            return FALSE;
        }
        file.Write(pBuf, NumBytes);  
        /*
        virtual void Write(  
            const void* lpBuf,   //存储要写的东西的字符串或者字符数组
            UINT nCount );   //要从这个字符串或者字符数组中写多少个字符到文件中
        */
        Total += NumBytes;
        file.Seek(Total, CFile::begin);
    }
    delete[] pBuf;
    file.Close();
    closesocket(client);
    return TRUE;
}

界面：