Windows Socket 编程 ： 支持多线程（TCP）(环境：VS2010)

最新推荐文章于 2020-10-09 19:22:15 发布
最新推荐文章于 2020-10-09 19:22:15 发布
阅读量8.5k 收藏 4
点赞数
分类专栏： Socket 文章标签： TCP 多线程

1. UserMesInfo.h 公共文件，客户端和服务器端公用；

#ifndef  User_Mes_Sock
#define  User_Mes_Sock
#include <winsock2.h>
#endif

const short  MesLogin   =  1001;
const short  MesError   =  1002;
const short  MesNormal  =  1003;
const short  LoginSuc   =  1004;
const short  MesToAll   =  1005;
const short  OnLineUser =  1010;


//User Struct
struct UserInfo
{
    short        userId;
    char         userName[32];
    SOCKET       userSock;
    LONG         userAddr;
    UserInfo     *pNext;
};

//Message Struct
struct MesInfo
{
    short        MesType;
    char         fromUserName[32];
    char         toUserName[32];
    char         MesContent[1024];
};

 

2. TCP：客户端程序

 

#include <iostream>
#include <stdlib.h>
#include <WinSock2.h>

#include "UserMesInfo.h"

#pragma comment(lib,"ws2_32.lib")

using namespace std;

BOOL isLogin = false;


string charToString(char temp[])
{
    string tempStr = "";
    for(int i = 0; i < sizeof(temp); i++)
        tempStr += temp[i];
    return tempStr;
}

BOOL SendMes(SOCKET servSocket)
{
    SOCKET servSock = servSocket;
    while(TRUE)
    {
        int tempWho;
        char sendBuff[1024] = {0};
        if(isLogin)
        {
            printf(" '1' : speak to ONE ;\n '2' : speak to ALL ;\n '3' : OnLine Users ; \n '4' : Exit ;\n");

            cin>>tempWho;
        }
        if( isLogin && tempWho == 1)
        {
            //To One
            printf("Please input NAME you want to CHAT : ");
            char toName[32] = {0};
            scanf("%s", toName);
            memcpy(sendBuff, &MesNormal, 2);
            memcpy(sendBuff+2, toName, 32);
            printf("Please input what do you want to say : ");
            char Message[1000] = {0};
            scanf("%s", Message);
            memcpy(sendBuff+34, Message, strlen(Message));
            send(servSock, sendBuff, sizeof(sendBuff)+1, 0);
        } else if(isLogin && tempWho == 2){
            //To ALL
            printf("Please input DATA : ");
            char Message[1000] = {0};
            scanf("%s", Message);

            memcpy(sendBuff, &MesToAll, 2);
            memcpy(sendBuff+2, Message, strlen(Message));
            send(servSock, sendBuff, sizeof(sendBuff)+1, 0);

        } else if(isLogin && tempWho == 3){
            char getOnLineUsers[4];
            memcpy(getOnLineUsers, &OnLineUser, 2);
            send(servSock, getOnLineUsers, sizeof(getOnLineUsers), 0);
        } else if(isLogin && tempWho == 4){
            break;
        } else if(isLogin){
            printf("You input Error! Please Again !");
        }
       
    }
    return TRUE;
}


DWORD WINAPI ProcThread(LPVOID lpParameter)
{
    SOCKET cliSocket = *(SOCKET*)lpParameter;

    //SOCKADDR_IN sockFrom ;
    //int length = sizeof(SOCKADDR);

    char recvBuf[1024] = {0};

    while(true)
    {
        memset(recvBuf, 0x00, 1024);
        int recvLen = recv(cliSocket, recvBuf, 1024, 0);
        if(recvLen > 0)
        {
            short megId = *(short*)recvBuf;
            switch(megId)
            {
            case LoginSuc:
                {
                    //char userName[32] = {0};
                    //memcpy(userName, recvBuf+2, 4);
                    printf("Login Success !\n");
                    isLogin = true;
                }
                break;
            case MesNormal:
                {
                    char Mess[1000];
                    memcpy(Mess, recvBuf+2, sizeof(recvBuf)-2);
                    printf(" ==> Me :%s\n", Mess);
                   
                }
                break;
            case MesToAll:
                {
                    char Mess[1000];
                    memcpy(Mess, recvBuf+2, sizeof(recvBuf)-2);
                    printf(" ==> All :%s\n", Mess);
                }
                break;
            case OnLineUser:
                {
                    char onLineUser[100] = {0};
                   
                    memcpy(onLineUser, recvBuf+2, sizeof(recvBuf)-2);

                    //string userStr = charToString(onLineUser);
                   
                    for(int i =0; i < sizeof(onLineUser); i++)
                        cout<<onLineUser[i];

                    //printf("%s\n", userStr);
                    cout<<endl<<onLineUser<<endl;
                    printf("\n");
           
                }
                break;
            default :
                break;
            }
        }//end if
    }// end while

    return 0;
}

int main()
{
    WORD wVersionRequested;
    WSADATA wsaData;
    int err;

    wVersionRequested = MAKEWORD(2, 2);

    err = WSAStartup(wVersionRequested, &wsaData);
    if (err != 0) {
        printf("WSAStartup failed with error: %d\n", err);
        return 1;
    }

    if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
        /* Tell the user that we could not find a usable */
        /* WinSock DLL.                                  */
        printf("Could not find a usable version of Winsock.dll\n");
        WSACleanup();
        return 1;
    }
    else
        printf("The Winsock 2.2 dll was found okay\n");


    SOCKET clientSock = socket(AF_INET, SOCK_STREAM, 0);

    if(clientSock == -1)
    {
        perror("socket创建出错！");
        exit(1);
    }

    SOCKADDR_IN addrClient;
    addrClient.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    addrClient.sin_family = AF_INET;
    addrClient.sin_port = htons(6000);


    int ret = connect(clientSock, (sockaddr*)&addrClient, sizeof(SOCKADDR));
    if (ret)
    {
        printf("连接失败\n");
        return -1;
    }

    HANDLE thHandle = CreateThread(NULL, 0, ProcThread, &clientSock, 0, NULL);

    if(NULL == thHandle)
    {
        cout<<"Create Thread failed !"<<endl;
        return -1;
    }

    char userName[32];
    printf("Please input name : ");
    scanf_s("%s", userName, 31);

    /*
    UserInfo* user = new UserInfo;
    user->userSock = clientSock;
    strcpy_s(user->userName, userName);
    user->userAddr = addrClient.sin_addr.S_un.S_addr;
    */
   
    char loginInfo[64] = {0};
    memcpy(loginInfo, &MesLogin, 2);
    memcpy(loginInfo+2, userName, strlen(userName));

   
    //int a = send(clientSock, loginInfo, strlen(loginInfo), 0);
    int a = send(clientSock, loginInfo, strlen(loginInfo), 0);
   
    SendMes(clientSock);

    //Sleep(20000);
    //closesocket(clientSock);
    CloseHandle(thHandle);
    WSACleanup();

   
    system("PAUSE");
    return 0;
}

 3.TCP：服务器端程序

 

#include <iostream>
#include <cstdlib>
#include <winsock2.h>
#include <string>
#include <Windows.h>
#include "UserMesInfo.h"

#pragma comment(lib,"ws2_32.lib")

using namespace std;

UserInfo *gUserInfo ;

string charToString(char temp[])
{
    string tempStr = "";
    for(int i = 0; i < sizeof(temp); i++)
        tempStr += temp[i];
    return tempStr;
}


DWORD WINAPI ProcMes(LPVOID lpParameter)
{
    SOCKET cliSocket = ((UserInfo*)lpParameter)->userSock;
    //SOCKADDR_IN sockFrom ;

    char recvBuf[1024];
    //int length = sizeof(SOCKADDR);

    while(true)
    {
        memset(recvBuf, 0x00, 1024);
        recv(cliSocket, recvBuf, 1024, 0);
       
        short MesType = *(short*)recvBuf;

        switch(MesType)
        {
        case MesLogin:
            {
                static short USERID = 1001;
                UserInfo* userInfo = new UserInfo;
                char* userName = (char*)(recvBuf + 2);
                strcpy_s(userInfo->userName, userName);
                userInfo->userId = USERID++;
                userInfo->userSock = cliSocket;
                userInfo->userAddr = ((UserInfo*)lpParameter)->userAddr;
                userInfo->pNext = NULL;

                if(!gUserInfo)
                {
                    gUserInfo = userInfo;
                }else
                {
                    userInfo->pNext = gUserInfo;
                    gUserInfo = userInfo;
                }
                printf("Login  :  %s ==> %d !\n", userInfo->userName, userInfo->userId);
               
                char loginInfo[4] = {0};
                memcpy(loginInfo, &LoginSuc, 2);
               
                int i = send(cliSocket, loginInfo, strlen(loginInfo), 0);
               
            }
            break;
        case MesNormal:
            {
                //printf("The Normal Message !");
                char toName[32] = {0};
                memcpy(toName, recvBuf+2, 32);
                cout<<toName<<endl;
                char Message[1000] = {0};
                memcpy(Message, recvBuf+34, sizeof(recvBuf)-34);
                printf("%s\n", Message);

                char sendMes[1006];
                memcpy(sendMes, &MesNormal, 2);
                memcpy(sendMes+2, recvBuf+34, sizeof(recvBuf)-34);
               
                //send(toSock, sendMes, sizeof(sendMes), 0);

                UserInfo* tempUser = gUserInfo;
                BOOL sendFlag = false;
                while(tempUser)
                {
                    if(!memcmp(toName, tempUser->userName, strlen(toName)))
                    {
                        SOCKET toSock = tempUser->userSock;
                        send(toSock, sendMes, strlen(sendMes)+1, 0);
                        sendFlag = true;
                    }
                    tempUser = tempUser->pNext;
                }
                if(!sendFlag)
                {
                    printf("Send Failed !\n");
                }
               
            }
            break;
        case MesToAll:
            {
                char Message[1000] = {0};
                memcpy(Message, recvBuf+2, sizeof(recvBuf)-2);
                UserInfo* tempUser = gUserInfo;
                char sendMes[1002];
                memcpy(sendMes, &MesToAll, 2);
                memcpy(sendMes+2, Message, sizeof(Message));
                while(tempUser)
                {
                    SOCKET toSock = tempUser->userSock;
                    int i = send(toSock, sendMes, strlen(sendMes)+1, 0);
                    if(i > 0)
                    {
                        printf("Send To %s Success !\n", tempUser->userName);
                    }
                    tempUser = tempUser->pNext;
                }
            }
            break;
        case MesError:
            //printf("The Error Message !");
            break;
        case OnLineUser:
            {
               
                char onLineUserBuff[1000] = {0};
                UserInfo* tempUser = gUserInfo;
               
                memcpy(onLineUserBuff, &OnLineUser, 2);

                int i = 0;
                string userStr = "";
                while(tempUser)
                {
                    userStr += charToString(tempUser->userName);
                    //处理方式有问题
                    //memcpy(onLineUserBuff+2, tempUser->userName, 32);
                    //send(cliSocket, onLineUserBuff, sizeof(onLineUserBuff), 0);
                    tempUser = tempUser->pNext;
                }
                memcpy(onLineUserBuff+2, userStr.c_str(), userStr.length());
                send(cliSocket, onLineUserBuff, sizeof(onLineUserBuff), 0);
                       
            }
            break;
        default:
            //printf("The Default Process !");
            break;
        }
   
    }

   
    return 0;
}

int main()
{
    WORD wVersionRequested;
    WSADATA wsaData;
    int err;

    wVersionRequested = MAKEWORD(2, 2);

    err = WSAStartup(wVersionRequested, &wsaData);
    if (err != 0) {
        printf("WSAStartup failed with error: %d\n", err);
        return 1;
    }

    if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
        /* Tell the user that we could not find a usable */
        /* WinSock DLL.                                  */
        printf("Could not find a usable version of Winsock.dll\n");
        WSACleanup();
        return 1;
    }
    else
        printf("The Winsock 2.2 dll was found okay\n");


    SOCKET servSock = socket(AF_INET, SOCK_STREAM, 0);

    SOCKADDR_IN addrServ ;
    addrServ.sin_family = AF_INET;
    addrServ.sin_port = htons(6000);
    addrServ.sin_addr.S_un.S_addr = htonl(INADDR_ANY);

    bind(servSock, (SOCKADDR*)&addrServ, sizeof(SOCKADDR));

    if(listen(servSock, 20) == SOCKET_ERROR)
    {
        printf("listen failed with error: %ld\n", WSAGetLastError());
        closesocket(servSock);
        WSACleanup();
        return -1;
    }


    while(true)
    {
        //wait for users Login, and create thread for it
        SOCKADDR_IN cliAddr;
        int length = sizeof(SOCKADDR);

        SOCKET cliSock = accept(servSock, (SOCKADDR*)&cliAddr, &length);

        if(INVALID_SOCKET == cliSock)
        {
            printf("listen failed with error: %ld\n", WSAGetLastError());
            closesocket(cliSock);
            WSACleanup();
            return -1;
        }

        UserInfo* user = new UserInfo;

        user->userSock = cliSock;
        user->userAddr = cliAddr.sin_addr.S_un.S_addr;

        //cout<<sizeof(user->userName)<<endl;

        HANDLE loginHandle = CreateThread(NULL, 0, ProcMes, (LPVOID)user, 0, NULL);

        if(NULL == loginHandle)
        {
            cout<<"Create Thread failed !"<<endl;
            return -1;
        }
        CloseHandle(loginHandle);

    }
    //Sleep(20000);
    closesocket(servSock);
    WSACleanup();

    system("PAUSE");
    return 0;
}

 

转自http://www.cnblogs.com/china-victory/archive/2012/11/17/2775404.html

awu999328
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Winsocket 多线程之单服务器多客户端
在到处之间找我
05-20 960
本文内容来自 http://www.rohitab.com/discuss/topic/26991-cc-how-to-code-a-multi-client-server-in-c-using-threads/ 文章目录服务器客户端说明TODO 服务器 #include <windows.h> #include <stdlib.h> #include <stdio....
vs2010实现socket客户端代码示例
07-31
简单地socket实现，入门者可看一看，没有具体的功能。
Windows Socket编程 多线程
04-18
课堂作业 socket编程 多线程 适合基础学习或者老师上课布置作业的
Windows下基于socket多线程并发通信的实现
ZP1015
04-07 2万+
本文介绍了在Windows 操作系统下基于TCP/IP 协议Socket 套接口的通信机制以及多线程编程知识与技巧，并给出多线程方式实现多用户与服务端(C/S)并发通信模型的详细算法，最后展现了用C++编写的多用户与服务器通信的应用实例并附有程序。 关键词：Windows；套接字；多线程；并发服务器； Socket 是建立在传输层协议（主要是TCP 和UDP）上的一种套接字规范，最初由美国加州Berkley 大学提出，为UNIX 系统开发的网络通信接口，它定义了两台计算机之间通信的规范，socket
VS2010 C# 你得学会并且学得会的Socket编程基础知识(Silverlight Socket编程)
binyao02123202的专栏
09-10 5456
这一篇文章，我将图文并茂地介绍Socket编程的基础知识，我相信，如果你按照步骤做完实验，一定可以对Socket编程有更好地理解。 本文源代码，可以通过这里下载 http://files.cnblogs.com/chenxizhang/SocketWorkshop.rar
MFC：Socket编程—TCP服务端和多个客户端通信 示例代码
01-12
在本文中，我们将深入探讨MFC（Microsoft Foundation Classes）中的Socket编程，特别是如何实现一个TCP服务端与多个客户端之间的通信。MFC是微软提供的一套C++类库，用于简化Windows应用程序开发，其中包括对网络...
tcp_socket VS2010实现_tcp_socketVS2010_vs2010下使用tcp_
09-29
总结，VS2010下的TCP_Socket编程涉及了网络基础、Winsock库的使用、套接字创建、连接管理、数据收发、异常处理等多个环节。通过理解和实践这些知识点，开发者可以构建出稳定可靠的网络通信程序。在实际项目中，还...
VS2017实现Tcp socket多线程通信（C++）
05-01
4. **多线程编程**：在TCP服务器端，多线程可以用于同时处理多个客户端连接。当一个新连接到来时，服务器创建一个新的线程来处理该连接，主服务线程则继续监听新的请求。这种方式提高了服务器的并发能力，但需要注意...
mp.rar_socket 多线程_tcp 多线程_tcp 线程_多线程 Socket_网络 扫描器
最新发布
09-14
标题中的“mp.rar_socket 多线程_tcp 多线程_tcp 线程_多线程 Socket_网络 扫描器”表明这是一个关于使用多线程Socket编程实现TCP网络扫描器的项目。TCP扫描器通常用于网络安全检测，通过尝试与目标主机建立连接，...
VS2010 C# TCP通信程序
12-17
VS2010 C# TCP通信程序全部源代码，使用Sockets类实现同步TCP通信。
vs2010中CSocket类编程
05-06
实验二：CSocket类编程 1、学会使用CSocket创建简单的TCP服务器以及客户机 2、理解C/C++的Socket编程； 3、熟悉C++网络编成及网络通信原理； 4、熟悉C/S网络通信模式和原理。
基于vs2010做的tcp通信调试工具源码
02-18
基于vs2010做的tcp通信调试工具，可以将接收到的数据进行保存，多线程操作。接收 发送数据。是软件调试的好工具。 包含源码，大家可以自己修改。
VS2010 TCP协议client和server简单通信例程
03-04
TCP工程可以在VS2010编译通过，亲测是可以使用的。机器环境是windows10 x64。不清楚的可以参考：https://blog.csdn.net/armwind/article/details/87564919
Windows下C++多线程SOCKET服务代码
05-08
网关程序：主要目的是作了一个中间程序转发网络消息，其实在网上有很多这样的程序，比如跨平台的ACE，目前版本为5.6，如果从ACE开始学习网关，个人觉得挺费劲的，我也曾经想用ACE编写网关程序，后来由于ACE的复杂性，还是胆怯了，还是自己下定决心写了一个网关程序。该网关程序目前只支持Windows，下一步的目标准备将程序移植到GCC环境下。程序中用到STL的std::map和std::list，也大量的运行了模板类，如：关于线程的参数ARGS即为模板类：template ARGS{}、还有一个就是SOCKET结构体：HOSTSTRUCTSTRCT的定义也是用到了模板类。程序的主要部份为：class CFramework 文件：framework.h framework.cpp，如果想编写一个网关程序，首先需要从该类继承，如目前例程中的：class CMyGateway；大家都知道网关程序即SOCKET通讯多线程程序，其中当然用到SOCKET；网关中有SOCKET服务端，也有SOCKET客户端；作为SOCKET服务端时，需要接收远程主机的连接，当远程主机请求连接，根据业务需要首先要验证该客户端是否是合法的客户，此时，需要从系统的允许访问队列表查询是否有该主机的信息，如果有该主机的信息，则允许该主机连接，此时触发OnConnected事件，在该事件中，可以接收客户端的登录信息，验证客户端的登录信息，如果验证成功，则将该主机信息添加到系统路由表中，当有消息需要转发到该主机时，从系统路由表取到目标主机的信息，通过host.fd发送消息；同理，网关作为一个客户端时，需要连接其它远程服务器，一旦连接上后，触发OnConnected事件，在该事件中，我们可以发送登录信息，并接收应答信息，解析应答信息，判断我们的登录是否成功，如果成功的话，将连接主机的信息添加到系统路由表中，当有其它信息需要转发到该主机时，从系统路由表中取到连接信息通过send() host.fd转发信息。在class CFramework中还有一定非常重要的函数：OnExecuteMessagte(const xuwn::MESSAGE& message)方法，这个方法是在从消息队列取到消息后执行的，xuwn::MESSAGE中定义了一个buffer即收到的消息，同时消息的长度为：message.size.nhead+message.size.nbody，您可以处理消息，在模拟程序中，我将消息转发到另外一个服务器即：B_HOST，HOSTSTRUCT的有个字段name即我称之为节点名称，该名称是我作为索引用的，在系统路由中只能存在这样一个KEY值的HOSTSTRUCT；在class CFramework中还有一个重要函数：OnRecvData(const HOSTSTRCT& host__, xuwn::MESSAGE& message)，这个方法是由我们执行如何接收消息的，因为大多数时候我们定义消息都为变长，即消息存在消息头＋消息体，大多时候，消息头为定长，消息体的长度在消息头中体现，当我们接收完消息头后，设置后继包（消息体）的长度，再调用CFramework::OnRecvData(host__, message)去接收消息体，并把消息写入到消息队列中。
多线程实现基于TCP的Socket通信.rar
07-27
本项目“多线程实现基于TCP的Socket通信”聚焦于在Windows环境下，如何利用C++编程语言通过多线程技术来实现高效、稳定的网络连接。下面将详细阐述涉及的知识点。 1. **TCP协议**：TCP是一种面向连接的、可靠的、...
vs2010编写的简单socket聊天
这里是菠萝味菠萝啤的博客
10-09 2934
服务器端 // server.cpp : 定义控制台应用程序的入口点。 //mfc用来了解win的操作系统的内核 #include "stdafx.h" #include<WinSock2.h>//引入头文件 #pragma comment(lib,"ws2_32.lib") //加载动态库 int _tmain(int argc, _TCHAR* argv[]) { //1,请求协议版本 WSADATA wsaData; WSAStartup(MAKEWORD(2,2),&w
c++下基于windows socket的多线程服务器(基于TCP协议)
翻肚鱼儿的博客
08-24 572
　之前用c++实现过基于windows socket的单线程TCP服务器(http://www.cnblogs.com/jzincnblogs/p/5170230.html)，今天实现了一个多线程的版本，可以接受多个客户端的请求，原理与之前的单线程版本相似，只是在多线程版本中主线程用于监测客户端请求，每当有新客户端请求连接，主线程便新开一个线程用户处理客户端的请求。代码如下： 　　头文件： 1 #ifndef SERVER_H 2 #define SERVER_H 3 4 #includ
c++/MFC 极为简单的socket实例
热门推荐
蜗牛的精神
11-20 4万+
本实例，也是我在网上找到的。感觉很基础，新手很适合。所以，就加以备注，给大家分享下。我也是一新手，学习mfc也就2个星期，本来一直弄php的。 简单来说下服务端的socket工作流程。 本实例代码下载，vs2010版本，打开就可以运行：http://download.csdn.net/detail/open520yin/4788263 最简单的mfc socket实例，适合新手。里面有服务端
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值