Windows网络编程（TCP流式套接字实验）

最新推荐文章于 2024-07-02 10:03:28 发布
最新推荐文章于 2024-07-02 10:03:28 发布
阅读量2.5k 收藏 40
点赞数 5
文章标签： socket 网络 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42714773/article/details/104704997
版权

一、
实验环境

Windows10 vs2017 c/c++

二、实验内容

1.设计思路

  1. 基于流式套接字的时间同步服务器设计

要求使用流式套接字编程，实现时间同步服务器和客户端，该服务器能够接收客户端的查询请求，获取本地时间，并将结果发送回客户端，客户端将该时间显示出来，如图1所示。

(1) time()函数、ctime()函数为时间处理函数。

(2)客户的recv函数需要循环接收。

在这里插入图片描述

在这里插入图片描述

1.1服务器（时间服务器）

#include "pch.h"

#include <iostream>

#include <time.h>

#include "winsock2.h"

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

#define BUF_SZIE 64

int main()

{

    WSADATA         wsd;        //WSADATA变量

    SOCKET          sServer;    //服务器套接字

    SOCKET          sClient;    //客户端套接字

    SOCKADDR_IN     addrServ;;      //服务器地址

    char        buf[BUF_SZIE];  //接收数据缓冲区

    char            buf1[BUF_SZIE];  //发送

    int             retVal;         //返回值

    //初始化套结字动态库

    if (WSAStartup(MAKEWORD(2, 2), &wsd) !=
0)

    {

        printf("WSAStartupfailed!\n");

        return -1;

    }

    //创建套接字

    sServer = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    if (INVALID_SOCKET == sServer)

    {

        printf("socketfailed!\n");

        WSACleanup();//释放套接字资源;

        return  -1;

    }

    //服务器套接字地址 

    addrServ.sin_family = AF_INET;

    addrServ.sin_port = htons(4999);

    addrServ.sin_addr.s_addr = INADDR_ANY;

    //绑定套接字

    retVal=bind(sServer(LPSOCKADDR)&addrServ,sizeof(SOCKADDR_IN));

    if (SOCKET_ERROR == retVal)

    {

        printf("bindfailed!\n");

        closesocket(sServer);    //关闭套接字

        WSACleanup();           //释放套接字资源;

        return -1;

    }

    //开始监听 

    retVal = listen(sServer, 3);

    if (SOCKET_ERROR == retVal)

    {

        printf("listenfailed!\n");

        closesocket(sServer);    //关闭套接字

        WSACleanup();           //释放套接字资源;

        return -1;

    }

        //接受客户端请求

        sockaddr_in addrClient;

        int addrClientlen = sizeof(addrClient);

        sClient=accept(sServer(sockaddr*)&addrClient,&addrClientlen);

        if (INVALID_SOCKET == sClient)

        {

            printf("acceptfailed!\n");

            closesocket(sServer);    //关闭套接字

            WSACleanup();           //释放套接字资源;

            return -1;

        }

        while (SOCKET_ERROR != retVal) {

            //接收客户端数据

            ZeroMemory(buf, BUF_SZIE);

            retVal = recv(sClient, buf, BUF_SZIE, 0);

            if (SOCKET_ERROR == retVal)

            {

                printf("recvfailed!\n");

                closesocket(sClient);    //关闭套接字

                closesocket(sServer);    //关闭套接字

                WSACleanup();           //释放套接字资源;

                return -1;

            }

            printf("%s\n", buf); //输出"MyTCP"

            //退出

            time_t t1;

            t1 = time(&t1);

            //      printf("%s\n", ctime(&t1));

            ZeroMemory(buf1, BUF_SZIE);

   ·         strcpy_s(buf1, ctime(&t1));

            retVal = send(sClient, buf1,strlen(buf1), 0);

            if (SOCKET_ERROR == retVal)

            {

                printf("sendfailed!\n");

                closesocket(sClient);    //关闭套接字

                WSACleanup();       //释放套接字资源

                return -1;

            }

        }

        closesocket(sClient);    //关闭套接字

    //}

    closesocket(sServer);    //关闭套接字

    WSACleanup();           //释放套接字资源;

    return 0;


}
1.2客户端（时间请求）

#include "pch.h"

#include <iostream>

#include <time.h>

#define  BUF_SZIE 64

#include "winsock2.h"

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

int main(int argc, char* argv[])

{

    WSADATA          wsd;         //WSADATA变量

    SOCKET           sHost;           //服务器套接字

    SOCKADDR_IN      servAddr;        //服务器地址

    char         buf[BUF_SZIE];   //发送数据缓冲区

    char         buf1[BUF_SZIE];  //接收数据缓冲区

    int              retVal;          //返回值

    //初始化套结字动态库

    if (WSAStartup(MAKEWORD(2, 2), &wsd) !=0)

    {

         printf("WSAStartupfailed!\n");

         return -1;

    }

    //创建套接字

    sHost= socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    if (INVALID_SOCKET == sHost)

    {

         printf("socketfailed!\n");

         WSACleanup();//释放套接字资源

         return  -1;

    }

    //设置服务器地址

    servAddr.sin_family= AF_INET;

    servAddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    servAddr.sin_port= htons((short)4999);

    int nServAddlen = sizeof(servAddr);

    //连接服务器

   retVal=connect(sHost(LPSOCKADDR)&servAddr,sizeof(servAddr));

    if (SOCKET_ERROR == retVal)

    {

         printf("connectfailed!\n");

        closesocket(sHost);   //关闭套接字

         WSACleanup();    //释放套接字资源

         return -1;

    }

    while (SOCKET_ERROR != retVal) {

         //向服务器发送数据

         ZeroMemory(buf, BUF_SZIE);

         strcpy_s(buf,"timeplease!");

         retVal= send(sHost, buf, strlen(buf), 0);

         if (SOCKET_ERROR == retVal)

         {

             printf("sendfailed!\n");

             closesocket(sHost);   //关闭套接字

             WSACleanup();    //释放套接字资源

             return -1;

         }

         ZeroMemory(buf1, BUF_SZIE);

         retVal= recv(sHost, buf1, BUF_SZIE, 0);

         if (SOCKET_ERROR == retVal)

         {

             printf("recvfailed!\n");

             closesocket(sHost);   //关闭套接字

             WSACleanup();         //释放套接字资源;

             return -1;

         }

         printf("%s\n", buf1); //输出

 

         Sleep(1000);

    }

    closesocket(sHost);   //关闭套接字

    WSACleanup();    //释放套接字资源

    return 0;

}

2．基于流式套接字的服务器回射程序设计

编写一服务器程序和客户程序，要求客户每输入一行数据，服务器接收后加上echo:回送给客户程序，当客户输入“q”后退出。

(1) 为了提高流式套接字网络程序对流数据的接收能力，以循环服务器方式分别实现以下要求：

a. 如图2所示，客户端接收数据以recvline接收一行数据。

b. 如图3所示，服务器和客户端接收数据以recvn定长方式接收，其中长度由运行程序时指定。

c. 如图4所示，服务器和客户端接收数据均以recvvl变长方式接收，即将发送的消息设计为消息头和消息体，消息头包含消息体的长度。

在这里插入图片描述

服务器：

#include "pch.h"

#include <iostream>

#include <time.h>

#include "winsock2.h"

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

#define  BUF_SZIE 64

using namespace std;

int main()

{

    WSADATA          wsd;         //WSADATA变量

    SOCKET           sServer;     //服务器套接字

    SOCKET           sClient;     //客户端套接字

    SOCKADDR_IN      addrServ;;       //服务器地址

    char         buf[BUF_SZIE];   //接收数据缓冲区

    char            buf1[BUF_SZIE];  //发送

    int              retVal;          //返回值

    //初始化套结字动态库

    if (WSAStartup(MAKEWORD(2, 2), &wsd) !=0)

    {

         printf("WSAStartup failed!\n");

         return -1;

    }

    //创建套接字

    sServer
= socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    if (INVALID_SOCKET == sServer)

    {

         printf("socketfailed!\n");

         WSACleanup();//释放套接字资源;

         return  -1;

    }

    //服务器套接字地址 

    addrServ.sin_family= AF_INET;

    addrServ.sin_port= htons(4999);

    addrServ.sin_addr.s_addr = INADDR_ANY;

    //绑定套接字

    retVal=bind(sServer(LPSOCKADDR)&addrServ,sizeof(SOCKADDR_IN));

    if (SOCKET_ERROR == retVal)

    {

         printf("bindfailed!\n");

         closesocket(sServer); //关闭套接字

         WSACleanup();         //释放套接字资源;

         return -1;

    }

    //开始监听 

    retVal= listen(sServer, 3);

    if (SOCKET_ERROR == retVal)

    {

         printf("listenfailed!\n");

         closesocket(sServer); //关闭套接字

         WSACleanup();         //释放套接字资源;

         return -1;

    }

    //接受客户端请求

    sockaddr_in addrClient;

    int addrClientlen = sizeof(addrClient);

    sClient=accept(sServer(sockaddr*)&addrClient,&addrClientlen);

    if (INVALID_SOCKET == sClient)

    {

         printf("acceptfailed!\n");

         closesocket(sServer); //关闭套接字

         WSACleanup();         //释放套接字资源;

         return -1;

    }

    //显示客户端的IP和端口

    char *pClientIP = inet_ntoa(addrClient.sin_addr);

    u_short  clientPort = ntohs(addrClient.sin_port);

    cout<< "Accept aclient." << endl;

    cout<< "IP: " << pClientIP << endl;

    cout<< "Port: " << clientPort << endl;

    //接收客户端数据并回射 

    while (SOCKET_ERROR != retVal) {

         ZeroMemory(buf, BUF_SZIE);

         retVal= recv(sClient, buf, BUF_SZIE, 0);

         if (SOCKET_ERROR == retVal)

         {

             printf("recvfailed!\n");

             closesocket(sClient); //关闭套接字

             closesocket(sServer); //关闭套接字

             WSACleanup();         //释放套接字资源;

             return -1;

         }

        printf("echo:%s\n", buf);

         ZeroMemory(buf1, BUF_SZIE);

         strcpy_s(buf1,"echo:");

        strncat(buf1, buf, BUF_SZIE);

         retVal= send(sClient, buf1, strlen(buf1), 0);

         if (SOCKET_ERROR == retVal)

         {

             printf("sendfailed!\n");

             closesocket(sClient); //关闭套接字

             WSACleanup();    //释放套接字资源

             return -1;

         }

    }

    closesocket(sClient); //关闭套接字

    closesocket(sServer); //关闭套接字

    WSACleanup();         //释放套接字资源;

    return 0;


客户端：

#include "pch.h"

#include <iostream>

#include <time.h>

#include <stdio.h>

#define  BUF_SZIE 64

#include "winsock2.h"

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

using namespace std;

BOOL RecvLine(SOCKET s, char* buf); //读取一行数据

int recvn(SOCKET s, char * recvbuf, unsigned int fixedlen);

int recvvl(SOCKET s, char * recvbuf, unsigned int recvbuflen);

int main(int argc, char* argv[])

{

 

    WSADATA          wsd;         //WSADATA变量

    SOCKET           sHost;           //服务器套接字

    SOCKADDR_IN      servAddr;        //服务器地址

    char         buf[BUF_SZIE];   //发送数据缓冲区

    char         buf1[BUF_SZIE];  //接收数据缓冲区

    int              retVal;          //返回值

    //初始化套结字动态库

    if (WSAStartup(MAKEWORD(2, 2), &wsd) !=0)

    {

         printf("WSAStartupfailed!\n");

         return -1;

    }

    //创建套接字

    sHost= socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    if (INVALID_SOCKET == sHost)

    {

         printf("socketfailed!\n");

         WSACleanup();//释放套接字资源

         return  -1;

    }

    //准备连接服务器

    cout<< "Clientsucceeded!" << endl;

    cout<< "Be ready toconnect to server..." << endl;

    //设置服务器地址

    servAddr.sin_family= AF_INET;

    servAddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    servAddr.sin_port= htons((short)4999);

    int nServAddlen = sizeof(servAddr);

    //连接服务器

    retVal=connect(sHost(LPSOCKADDR)&servAddr,sizeof(servAddr));

    if (SOCKET_ERROR == retVal)

    {

         printf("connect
failed!\n");

         closesocket(sHost);   //关闭套接字

         WSACleanup();    //释放套接字资源

         return -1;

    }

    //连接服务器成功

    cout<< "Connectsuccessfully!" << endl;

    while (SOCKET_ERROR != retVal) {

         //向服务器发送数据

         ZeroMemory(buf, BUF_SZIE);

         gets_s(buf);

         unsigned int len = strlen(buf);//获取读入字符串长度。

         buf[len]= '\n';//结尾增加换行符。

         buf[len+ 1] = '\0';//赋值新的结束符

         if (buf[0] == 'q' || buf[0] == 'Q') break;

         retVal= send(sHost, buf, strlen(buf), 0);

         if (SOCKET_ERROR == retVal)

         {

             printf("send failed!\n");

             closesocket(sHost);   //关闭套接字

             WSACleanup();    //释放套接字资源

             return -1;

         }

         //行接收

             if (!RecvLine(sHost,buf1))

             {

                 printf("recvfailed!\n");

                 closesocket(sHost);   //关闭套接字

                 WSACleanup();         //释放套接字资源;

                 return -1;

             }

             printf("%s\n", buf1);

    }

    closesocket(sHost);   //关闭套接字

    WSACleanup();    //释放套接字资源

    return 0;

}

BOOL RecvLine(SOCKET s, char* buf)

{

    BOOL retVal = TRUE;            //返回值

    BOOL bLineEnd = FALSE;     //行结束

    int      nReadLen = 0;         //读入字节数

    int      nDataLen = 0;         //数据长度

    ZeroMemory(buf, BUF_SZIE);

    while (!bLineEnd) //与客户端连接 没有换行

    {

         nReadLen= recv(s, buf + nDataLen, 1, 0);//每次接收一个字节

         //错误处理

         if (SOCKET_ERROR == nReadLen)

         {

             retVal= FALSE;  //读数据失败

             break;           //跳出循环                     

         }

         if (0 == nReadLen)//客户端关闭

         {

             retVal= FALSE;  //读数据失败

             break;           //跳出循环            

         }

         //读入数据

         if ('\n' == *(buf + nDataLen)) //换行符

         {

             bLineEnd= TRUE;          //接收数据结束

         }

         else {

             nDataLen+= nReadLen;     //增加数据长度

         }

    }

    return retVal;

}

在这里插入图片描述


服务器：（主要代码）

    //接收客户端数据并回射 

    while (SOCKET_ERROR != retVal) {

         ZeroMemory(buf, BUF_SZIE);

         int iResult =recvn(sClient, buf, 2);

         if (iResult != 2)

         {

             //如果变长消息在接收时没有返回足够的数据就返回0（连接关闭）或-1（发生错误）

             if (iResult == -1)

             {

                 printf("接收发生错误: %d\n",WSAGetLastError());

                 return -1;

             }

             else

             {

                 printf("连接关闭\n");

                 return 0;

             }

         }

        printf("ehco:%s\n", buf);

         ZeroMemory(buf1, BUF_SZIE);

         strcpy_s(buf1,"echo:");

         strncat(buf1,buf, BUF_SZIE);

         retVal= send(sClient, buf1, strlen(buf1), 0);

         if (SOCKET_ERROR == retVal)

         {

             printf("sendfailed!\n");

             closesocket(sClient); //关闭套接字

             WSACleanup();    //释放套接字资源

             return -1;

         }

    }

int recvn(SOCKET s, char * recvbuf, unsigned int fixedlen)

{

    int iResult;//存储单次recv操作的返回值

    int cnt;//用于统计相对于固定长度，剩余多少字节尚未接收

    cnt= fixedlen;

    while (cnt > 0)

    {

         iResult= recv(s, recvbuf, cnt, 0);

         if (iResult < 0)

         {

             //数据接收出现错误，返回失败

             printf("接收发生错误: %d\n", WSAGetLastError());

             return -1;

         }

         if (iResult == 0)

         {

             //对方关闭连接，返回已接收到的小于fixedlen的字节数

             printf("连接关闭\n");

             return fixedlen - cnt;

         }

         //接收缓存指针向后移动

         recvbuf += iResult;

         //更新cnt值

         cnt-= iResult;

    }

    return fixedlen;

}

在这里插入图片描述


服务器：

   //接收客户端数据并回射 

   while (SOCKET_ERROR != retVal) {

        ZeroMemory(buf, BUF_SZIE);

        retVal= recvvl(sClient, buf, BUF_SZIE);

        if (SOCKET_ERROR == retVal)

        {

            printf("recv failed!\n");

            closesocket(sClient); //关闭套接字

            closesocket(sServer); //关闭套接字

            WSACleanup();         //释放套接字资源;

            return -1;

        }

        printf("ehco:%s\n", buf);

        ZeroMemory(buf1, BUF_SZIE);

        strcpy_s(buf1,"echo:");

        strncat(buf1,buf, BUF_SZIE);



        unsigned int len = (unsigned int)strlen(buf1);

        len= htonl(len);

        retVal= send(sClient, (char*)&len, sizeof(unsigned int), 0);

        if (SOCKET_ERROR == retVal)

        {

            printf("send failed!\n");

            closesocket(sClient); //关闭套接字

            WSACleanup();    //释放套接字资源

            return -1;

        }



        retVal= send(sClient, buf1, strlen(buf1), 0);

        if (SOCKET_ERROR == retVal)

        {

            printf("sendfailed!\n");

            closesocket(sClient); //关闭套接字

            WSACleanup();    //释放套接字资源

            return -1;

        }

   }

int recvn(SOCKET s, char * recvbuf, unsigned int fixedlen)

{

   int iResult;//存储单次recv操作的返回值

   int cnt;//用于统计相对于固定长度，剩余多少字节尚未接收

   cnt= fixedlen;

   while (cnt > 0)

   {

        iResult= recv(s, recvbuf, cnt, 0);

        if (iResult < 0)

        {

            //数据接收出现错误，返回失败

            printf("接收发生错误: %d\n", WSAGetLastError());

            return -1;

        }

        if (iResult == 0)

        {

            //对方关闭连接，返回已接收到的小于fixedlen的字节数

            printf("连接关闭\n");

            return fixedlen - cnt;

        }

        //printf("接收到的字节数: %d\n", iResult);

        //接收缓存指针向后移动

        recvbuf += iResult;

        //更新cnt值

        cnt-= iResult;

   }

   return fixedlen;

}

int recvvl(SOCKET s, char * recvbuf, unsigned int recvbuflen)

{

   int iResult;//存储单次recv操作的返回值

   unsigned int reclen; //用于存储报文头部存储的长度信息

   //获取接收报文长度信息

   iResult= recvn(s, (char *)&reclen, sizeof(unsigned int));

   if (iResult != sizeof(unsigned int))

   {

        //如果长度字段在接收时没有返回一个整型数据就返回0（连接关闭）或-1（发生错误）

        if (iResult == -1)

        {

            printf("接收发生错误: %d\n", WSAGetLastError());

            return -1;

        }

        else

        {

            printf("连接关闭\n");

            return 0;

        }

   }

   //转换网络字节顺序到主机字节顺序

   reclen= ntohl(reclen);

   if (reclen > recvbuflen)

   {

        //如果recvbuf没有足够的空间存储变长消息，则接收该消息并丢弃，返回错误

        while (reclen > 0)

        {

            iResult= recvn(s, recvbuf, recvbuflen);

            if (iResult != recvbuflen)

            {

                //如果变长消息在接收时没有返回足够的数据就返回0（连接关闭）或-1（发生错误）

                if (iResult == -1)

                 {

                     printf("接收发生错误: %d\n", WSAGetLastError());

                     return -1;

                 }

                else

                {

                     printf("连接关闭\n");

                     return 0;

                }

            }

            reclen-= recvbuflen;

            //处理最后一段数据长度

            if (reclen < recvbuflen)

                recvbuflen = reclen;

        }

        printf("可变长度的消息超出预分配的接收缓存\r\n");

        return -1;

   }

   //接收可变长消息

   iResult= recvn(s, recvbuf, reclen);

   if (iResult != reclen)

   {

        //如果消息在接收时没有返回足够的数据就返回0（连接关闭）或-1（发生错误）

        if (iResult == -1)

        {

            printf("接收发生错误: %d\n", WSAGetLastError());

            return -1;

        }

        else

        {

            printf("连接关闭\n");

            return 0;

        }

   }

   return iResult;

}

并发服务器

并发服务器：

#include "pch.h"

#include <iostream>

#include <time.h>
#include "winsock2.h"
#pragma comment(lib, "ws2_32.lib")

#define  BUF_SZIE 64

using namespace std;


typedef struct my_file

{

 

    SOCKET clientSocket; //文件内部包含了一个SOCKET 用于和客户端进行通信

 

    sockaddr_in clientAddr; //用于保存客户端的socket地址

 

    int id; //文件块的序号

 

}F;

 DWORD WINAPI mywork(const LPVOID arg)

{

    char         buf[BUF_SZIE];   //接收数据缓冲区

    char            buf1[BUF_SZIE];  //发送

    int              retVal=0;             //返回值

    F *temp = (F*)arg;

    char *pClientIP =inet_ntoa(temp->clientAddr.sin_addr);

    u_short  clientPort = ntohs(temp->clientAddr.sin_port);

    cout<< "Accept a client." << endl;

    cout<< "IP: " << pClientIP << endl;

    cout<< "Port: " << clientPort << endl;

    //接收客户端数据并回射 

    

    while (SOCKET_ERROR != retVal) {

         ZeroMemory(buf, BUF_SZIE);

         retVal= recv(temp->clientSocket, buf, BUF_SZIE, 0);

         if (SOCKET_ERROR == retVal)

         {

             printf("recvfailed!\n");

             closesocket(temp->clientSocket);   //关闭套接字

             return -1;

         }

         printf("%s\n", buf);

 

         ZeroMemory(buf1, BUF_SZIE);

         strcpy_s(buf1,"echo:");

         strncat(buf1,buf, BUF_SZIE);

 

         retVal= send(temp->clientSocket, buf1, strlen(buf1), 0);

         if (SOCKET_ERROR == retVal)

         {

             printf("send failed!\n");

             closesocket(temp->clientSocket);   //关闭套接字

             return -1;

         }

    }

 

    closesocket(temp->clientSocket);   //关闭套接字

}

 

 

int main()

{

    WSADATA          wsd;         //WSADATA变量

    SOCKET           sServer;     //服务器套接字

    SOCKET           sClient;     //客户端套接字

    SOCKADDR_IN      addrServ;;       //服务器地址

    char         buf[BUF_SZIE];   //接收数据缓冲区

    char            buf1[BUF_SZIE];  //发送

    int              retVal;          //返回值

 

    //初始化套结字动态库

    if (WSAStartup(MAKEWORD(2, 2), &wsd) !=
0)

    {

         printf("WSAStartupfailed!\n");

         return -1;

    }

 

    //创建套接字

    sServer= socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    if (INVALID_SOCKET == sServer)

    {

         printf("socketfailed!\n");

         WSACleanup();//释放套接字资源;

         return  -1;

    }

 

    //服务器套接字地址 

    addrServ.sin_family= AF_INET;

    addrServ.sin_port= htons(4999);

    addrServ.sin_addr.s_addr = INADDR_ANY;

    //绑定套接字

    retVal= bind(sServer, (LPSOCKADDR)&addrServ, sizeof(SOCKADDR_IN));

    if (SOCKET_ERROR == retVal)

    {

         printf("bindfailed!\n");

         closesocket(sServer); //关闭套接字

         WSACleanup();         //释放套接字资源;

         return -1;

    }

 

    HANDLE hThread[20]; //获取句柄

 

    //开始监听 

    retVal= listen(sServer, 20);

    if (SOCKET_ERROR == retVal)

    {

         printf("listenfailed!\n");

         closesocket(sServer); //关闭套接字

         WSACleanup();         //释放套接字资源;

         return -1;

    }

    

    for (int i = 0; i < 20;i++) {

             F *temp = new F; //创建新的传输结构体         

             sockaddr_in clntAddr;     

             int nSize = sizeof(SOCKADDR);      

             SOCKET clientSock=accept(sServer(SOCKADDR*)&clntAddr,&nSize);     //temp数据成员赋值     

             temp->clientSocket= clientSock;       

             temp->id= i + 1;     

             temp->clientAddr= clntAddr;       //通过句柄创建子线程         

             hThread[i]= CreateThread(NULL, 0, &mywork, temp, 0, NULL);  

         }   

    WaitForMultipleObjects(20,hThread, TRUE, INFINITE);

 

    cout<< WSAGetLastError() << endl; //查看错误信息

    closesocket(sServer); //关闭套接字

    WSACleanup();         //释放套接字资源;

    cout<< "serverclose!" << endl;

    return 0;
}
beaverrr
关注
  • 5
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
windows socket网络编程实验教程
09-14
windows socket网络编程实验教程，包含socket基本实验、连接FTP实验、消息传递应用程序三个部分。简洁明了，对理解网络通信很有帮助。
C#实现的流式套接字程序（TCP协议）
11-22
C#作为.NET框架的一部分，提供了丰富的类库支持流式套接字编程，使得开发者可以方便地创建可靠的、面向连接的网络应用程序。 TCP是一种面向连接的、可靠的传输层协议，它确保了数据包的顺序传输和错误检查，通过三...
Windows网络编程——课后实验：基于TCP协议的Socket编程
weixin_65869986的博客
09-25 531
3.首先启动服务器程序，然后启动客户端程序，当两者建立连接之后开始通信（在控制台窗口输入通信内容）。当客户端输入“quit”之后，双方通信结束。由于课本上有面向连接的Socket编程实现步骤，且作者在代码中注入了大量注释，所以作者在这里不做过多赘述。基于TCP协议，编写面向连接的Socket通信程序，包含服务器端程序和客户端程序，实现客户端和服务器端之间的通信。）展示程序逻辑，以及为写代码不熟练的同学提供一个参考板子。1.只能在Socket中使用TCP协议。2.实现客户端和服务器阻塞状态通信。
高级网络程序设计-基于流式套接字的计算程序设计
qq_53045284的博客
12-13 1366
HIT高级网络程序设计实验，windows，VS2019，
（TCP IP网络编程）实验一 流式套接字编程
weixin_44209522的博客
06-16 3101
一．实验目的 1）熟悉Linux环境下流式套接字编程的基本模型、函数使用细节等，掌握Linux环境下流式套接字编程的具体过程。 2）熟悉Windows环境下流式套接字编程的基本模型、函数使用细节等，掌握Windows环境下流式套接字编程的具体过程。 二．实验内容 （1） 使用流式套接字实现一个Linux环境下的迭代回声服务器端(及客户端)； （2） 使用流式套接字实现一个Windows环境下的迭代回声服务器端(及客户端)。 （3）使服务器端和客户端各传递1次字符串。考虑到使用TCP协议，所以传递字符串
TCP套接字编程
写博客记录分享学习笔记
04-13 883
Linux操作系统下TCP套接字编程
流式套接字并发服务器【基于流式套接字的网络程序设计】
一只猫猫的博客
12-01 1229
流式套接字并发服务器 主线程： 创建套接字并将其绑定到服务器所使用的熟知地址上。 重复调用accept接收客户端的请求,并且创建子线程处理响应。 子线程： 在线程创建时接收连接请求； 用该连接与客户端进行交互：接收请求并发回应答； 关闭连接并退出。子线程在处理完来自一个客户端的所有请求后退出
Socket基础三：基于流式套接字的网络程序（服务器回射程序设计)
qq_44807456的博客
04-27 2491
作者：刘磊 2020.4.27 　　　参考书目：《Windows网络编程》刘琰等著 回射程序 回射程序是进行网络诊断的常用工具之一，例如Ping是windows系统下自带的可执行命令，利用它可以检查网络是否连通，不过ping是网络层上的，不适合传输层的应用程序测试和诊断。 基本执行步骤 服务器： 引用头文件 创建流式套接字 捆绑服务器的指定端口到套接字 把套接...
TCP.zip_letter4tt_purposest2_tcp_windows网络编程_基于流式套接字的客户端设计
09-25
在本文中，我们将深入探讨如何在Windows环境下进行TCP网络编程，特别是基于流式套接字的客户端设计。TCP（Transmission Control Protocol）是一种面向连接的、可靠的传输协议，广泛应用于互联网通信。流式套接字...
流式套接字编程实验
06-19
流式套接字编程实验是网络通信领域中的一个重要实践，主要涉及TCP/IP协议栈中的TCP（传输控制协议），它提供了一种面向连接、可靠的数据传输服务。在这个实验中，我们将探讨如何利用流式套接字实现回射服务器和...
基于数据报套接字的回射程序设计与实验报告加源码
12-01
1、利用数据报套接字编写回射服务器和客户端。 2、使用类的形式封装服务器和客户端的网络功能框架，提高程序的适用性。 3、在编程框架的基础上扩展程序功能，测试网络丢包率。
TCP_Echo流式套接字回射程序
12-03
本项目“TCP_Echo流式套接字回射程序”是针对Windows平台，使用C++语言实现的一个示例，它展示了如何利用TCP流式套接字创建一个回射服务器和客户端。下面将详细介绍这个程序涉及的关键知识点。 1. **TCP协议**：TCP...
流式套接字实现简单的客户端服务端通信过程
12-10
流式套接字，也称为TCP（Transmission Control Protocol）套接字，是网络编程中常用的一种数据传输方式。TCP提供了一种面向连接、可靠的数据传输服务，确保了数据的顺序和完整性，适用于需要稳定、高效交换大量数据...
TCP实现之：套接字
qq_17045267的博客
06-16 1938
TCP实现之：套接字 套接字的数据结构按照域的不同可以分为三种：用户态套接字、socket和sock，其中socket结构体是内核中的与用户态相似的套接字数据结构，可以理解为它是为用户态提供的一种接口，而sock结构体比较复杂，它是内核用来进行数据传输的数据结构，可以理解为它是套接字的实现。这三种套接字可谓息息相关。 struct socket 这里的socket又被称为BSD socket（伯克利套接字），它对应着网络模型中的表示层，其定义比较简单，只有7个字段，如下： struct socket {
基于数据报套接字的服务器回射程序设计_Linux 下的进程间通信：套接字和信号...
weixin_39576066的博客
11-23 137
学习在 Linux 中进程是如何与其他进程进行同步的。-- Marty Kalin(作者)本篇是 Linux 下 进程间通信 (IPC)系列的第三篇同时也是最后一篇文章。 第一篇文章 聚焦在通过共享存储(文件和共享内存段)来进行 IPC， 第二篇文章 则通过管道(无名的或者命名的)及消息队列来达到相同的目的。这篇文章将目光从高处(套接字)然后到低处(信号)来关注 IPC。代码示例将用力地充实下面的...
基于数据报套接字的服务器回射程序设计_套接字Socket的常见面试题及答案
weixin_39836726的博客
11-22 200
1. 对套接字编程的理解，它的协议是如何的？socket通常称为“套接字”，用于描述IP地址和端口，是一个通信链的句柄。应用程序通过套接字向网络发出请求或应答网络请求。服务器和客户端通过socket进行交互。服务器需要绑定在本机的某个端口号上，客户端需要声明自己连接哪个地址的哪个端口，这样服务器和客户端就能连接了。根据连接启动的方式以及本地套接字要连接的目标，套接字之间的连接过程可以分为三个步骤：...
网络编程之流式套接字
m0_62574258的博客
03-27 1241
流式套接字（SOCK_STREAM）是一种网络编程接口，它提供了一种面向连接的、可靠的、无差错和无重复的数据传输服务。而作为服务器，一般是工作在被动连接的方式下，所以必须通过显示的调用bind()将监听套接字绑定到一个端口上，以等待客户端的连接。服务端：socket() --> bind() --> listen() --> accept() --> recv() --> close()客户端：socket() --> connect() --> send() --> recv() --> close()
socket——流式套接字编程实例及注意事项
cprimesplus的博客
02-21 780
流式套接字基本操作步骤 C端（主动端） 获取socket 给socket取得地址（可省） 发送连接 收发消息 关闭 S端（被动端） 获取socket 给socket取得地址 将socket设置为监听模式 接受连接 收发消息 关闭 ...
windows网络进阶之listen参数含义
最新发布
m0_62681656的博客
07-02 787
在Windows网络编程中，在使用TCP时，listen函数它是一个重要的关键的步骤，使得套接字能够接收传入的连接请求，下面我主要通过实战案例讲解listen参数的含义。注：本章是一个进阶篇，前提是能够掌握基础windows网络编程概念。二、listen参数1.SOCKET s这是一个已绑定（通过bind函数）的套接字,作用用于接收客户端的连接请求。这个参数比较好理解，我们重点讲解第二个参数。挂起的连接队列的最大长度。
《网络编程技术》试题-2.docx
12-18
3. 套接字函数：`socket()`函数用于创建套接字，可以创建流式套接字（TCP）、数据报套接字（UDP）或原始套接字。`bind()`函数将套接字与本地地址关联，`connect()`用于建立连接。当这些函数出错时，返回-1，错误代码...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值