基于数据报套接字的服务器回射程序设计：分别以循环服务器和并发服务器实现

于 2021-12-01 11:02:34 发布
阅读量4k 收藏 20
点赞数 2
分类专栏： 计算机网络实验 文章标签： 计算机网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41581354/article/details/121643621
版权

目录

一、基于数据报套接字的服务器回射程序设计

基于数据报套接字的服务器回射程序设计内容：

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

要求分别以循环服务器和并发服务器实现。

图1 回射程序

无连接的数据报套接字回射客户端 设计思路

请添加图片描述

循环服务器 设计思路

请添加图片描述

并发服务器 设计思路

为了解决接收客户端的多次交互的请求的问题，在客户端发出第一个“ASK Port”请求后服务器为每个客户创建一个的新的套接字，在其上 bind 一个临时端口，创建一个子进程使用该套接字发送对该客户的所有应答。要求客户端查看服务器第一个应答的中的源端口号，并把本请求的后续数据报发送到该端口。

二、代码实现

客户端代码（循环服务器对应的）

#define NETWORK1_2_1_A_COMM_H
#define NETWORK1_2_1_A_COMM_H
#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
#include <inaddr.h>
#include <time.h>
#include <string.h>
#pragma comment(lib, "ws2_32.lib")
#define MAXLINE 4096     // 接收缓冲区长度
#define LISTENQ 1024     // 监听队列长度
#define SEVER_PORT 13442 // 端口 
/*套接字初始化*/ 
int StartUp()
{
    WORD w_version = MAKEWORD(2, 2);
    WSADATA wsa_data;
    int res = WSAStartup(w_version, &wsa_data);
    if (res != 0)
    {
    	printf("WSAStartup Error:%d\n",WSAGetLastError());
        return -1;
    }//版本号错误 
    if (LOBYTE(wsa_data.wVersion) != 2 || HIBYTE(wsa_data.wVersion) != 2)
    {
       	printf("WSAStartup Error:%d\n",WSAGetLastError());
        WSACleanup();
        return -1;
    }

    return 0; //成功返回0 
}
/*释放资源*/ 
int cleanUp()
{
    int res = WSACleanup();
    if (res == SOCKET_ERROR)
    {
    	printf("WSACleanup Error:%d",WSAGetLastError()); 
        return -1;
    }
    return 0;
}
/*断开连接，释放资源*/ 
int closeConn(SOCKET sock_conn)
{
    int res = closesocket(sock_conn); //关闭连接
    if (res == SOCKET_ERROR)
    {
    	printf("关闭连接失败%d\n",WSAGetLastError());
        return -1;
    }
    res = cleanUp();
    return res;
}
/*连接服务器并绑定*/
SOCKET udpClientInit(char *server_ip, u_short port, sockaddr_in &server_addr, bool flag)
{
    int res = -1;
    SOCKET sock_conn;
    // 绑定地址、端口
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(port);
    server_addr.sin_addr.S_un.S_addr = inet_addr(server_ip);
    //创建套接字
    sock_conn = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock_conn == INVALID_SOCKET)
    {
    	printf("连接初始化失败%d\n",WSAGetLastError());
        cleanUp();
        return -1;
    }

    if (flag)
    {
        // 请求连接服务器
        res = connect(sock_conn, (struct sockaddr *)&server_addr, sizeof(server_addr));
        if (res == SOCKET_ERROR)
        {
            // 连接服务器失败
            printf("连接失败：%d\n",WSAGetLastError()); 
            closeConn(sock_conn);
            return -1;
        }
    }

    return sock_conn; //连接成功
}
int getline(char s[],int lim)
{
    int c,i;
    i=0;
    while((c=getchar())!=EOF&&c!='\n'&&i<lim-1)
        s[i++]=c;
    s[i]='\0';
    return i;
}
/*回射客户端发送接收程序*/
int udpEchoClient(SOCKET sock_conn, SOCKADDR *server_addr, int addr_len)
{
    int res = -1;
    char send_data[MAXLINE], recv_data[MAXLINE];
    memset(send_data, 0, MAXLINE);
    memset(recv_data, 0, MAXLINE);
	 
    while (getline(send_data, MAXLINE))//输入缓冲区接收一行数据 
    {
        // 结束
        if (*send_data == 'Q' || *send_data == 'q')
        {
            puts("退出"); 
            return 0; // 正常退出
        }
        // 发送数据
        res = sendto(sock_conn, send_data, (int)strlen(send_data), 0, (SOCKADDR *)server_addr, addr_len);
        if (res == SOCKET_ERROR)
        {
        	printf("发送失败：%d\n",WSAGetLastError());
            return -1;
        }
		printf("发送数据：%s\n",send_data); 
        // 接收数据
        res = recvfrom(sock_conn, recv_data, MAXLINE, 0, NULL, NULL);
        if (res > 0)
        {
        	printf("接收到的数据:%s\n",recv_data);
        }
        else
        {
            printf("接收失败：%d\n",WSAGetLastError());
            break;
        }

        // 清空缓存
        memset(recv_data, 0, MAXLINE);
        memset(send_data, 0, MAXLINE);
    }
    return res;
}
int main()
{
    int res = -1;
    SOCKET sock_conn;
    struct sockaddr_in server_addr;
    char server_ip[] = "10.236.10.200";
    res = StartUp();//初始化动态连接库 
    if (res == -1) return -1;

    sock_conn = udpClientInit(server_ip, SEVER_PORT, server_addr, true);//连接初始化 
    if (sock_conn == -1) return -1;
	puts("连接服务器成功");
    res = udpEchoClient(sock_conn, (SOCKADDR *)&server_addr, sizeof(sockaddr_in));
    if (res == -1)puts("Error");
    closeConn(sock_conn); 
    return res;
}

循环服务器端代码

//回射程序，服务器段端，循环服务器 
#define NETWORK1_2_1_A_COMM_H
#define NETWORK1_2_1_A_COMM_H
#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
#include <inaddr.h>
#include <time.h>
#include <string.h>
#pragma comment(lib, "ws2_32.lib")
#define MAXLINE 4096     // 接收缓冲区长度
#define LISTENQ 1024     // 监听队列长度
#define SEVER_PORT 13442 // 端口 
/*套接字初始化*/ 
int StartUp()
{
    WORD w_version = MAKEWORD(2, 2);
    WSADATA wsa_data;
    int res = WSAStartup(w_version, &wsa_data);
    if (res != 0)
    {
    	printf("WSAStartup Error:%d\n",WSAGetLastError());
        return -1;
    }//版本号错误 
    if (LOBYTE(wsa_data.wVersion) != 2 || HIBYTE(wsa_data.wVersion) != 2)
    {
       	printf("WSAStartup Error:%d\n",WSAGetLastError());
        WSACleanup();
        return -1;
    }

    return 0; //成功返回0 
}
/*释放资源*/ 
int cleanUp()
{
    int res = WSACleanup();
    if (res == SOCKET_ERROR)
    {
    	printf("WSACleanup Error:%d",WSAGetLastError()); 
        return -1;
    }
    return 0;
}
/*断开连接，释放资源*/ 
int closeConn(SOCKET sock_conn)
{
    int res = closesocket(sock_conn); //关闭连接
    if (res == SOCKET_ERROR)
    {
    	printf("关闭连接失败%d\n",WSAGetLastError());
        return -1;
    }
    res = cleanUp();
    return res;
}
/*服务器初始化*/ 
SOCKET udpServerInit(int port)
{
    int res = -1;
    SOCKET sock_listen;
    const int on = 1;

    // 绑定地址、端口
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(port);

    //创建监听套接字
    sock_listen = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock_listen == INVALID_SOCKET)
    {
    	
       	printf("WSAStartup Error:%d\n",WSAGetLastError());
       	cleanUp();
        return -1;
    }

    //绑定服务器地址
    res = bind(sock_listen, (struct sockaddr *)&server_addr, sizeof(server_addr));
    if (res == SOCKET_ERROR)
    {
    	printf("绑定失败:%d\n",WSAGetLastError());
        closeConn(sock_listen);
        return -1;
    }

    return sock_listen;
}
/*循环服务器接收程序*/ 
int udpEchoServer(SOCKET sock_conn)
{
    // 此处利用指针的移动 实现添加Echo
    int res = -1;
    char recv_data[MAXLINE];
    struct sockaddr_in client_addr;
    int addr_len = sizeof(client_addr);

    do
    {
        // 清空缓存
        memset(recv_data, 0, MAXLINE);

        // 循环接收数据
        res = recvfrom(sock_conn, recv_data , MAXLINE , 0, (SOCKADDR *)&client_addr, &addr_len);
        if (res > 0)
        {
			printf("从客户端接受到数据:%s：\n",recv_data);
            // 回射接收的数据
            res = sendto(sock_conn, recv_data, res , 0, (SOCKADDR *)&client_addr, addr_len);
            if (res == SOCKET_ERROR)
            {
            	printf("sendto error:%d\n",WSAGetLastError()); 
                res = -1;
            }
            else
            {
            	printf("服务器回射数据：%s\n",recv_data);
            }
        }
        else
        {
            printf("recvfrom error:%d\n",WSAGetLastError()); 
            res = -1;
        }
    } while (res > 0);

    return res;
}
int main(int argc, char *argv[])
{
    int res = -1;
    SOCKET sock_listen;
    res = StartUp();//初始化 
    if (res == -1) return -1;//初始化失败 
    sock_listen = udpServerInit(SEVER_PORT);//创建监听套接字 
    if (sock_listen == -1) return -1;
	puts("udpServerInit success") ;
	//循环服务器 
    while (1)
    {
        // 回射 如果出错，继续其他客户端请求
        res = udpEchoServer(sock_listen);
        if (res == -1) puts("cilent connectione error,continue to connect to the next client"); 
    }
    closeConn(sock_listen); // 关闭监听服务
    return 0;
}

并发服务器端代码

#define NETWORK1_2_1_A_COMM_H
#define NETWORK1_2_1_A_COMM_H
#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
#include <windows.h>
#include <inaddr.h>
#include <time.h>
#include <string.h>
#pragma comment(lib, "ws2_32.lib")
#define MAXLINE 4096     // 接收缓冲区长度
#define LISTENQ 1024     // 监听队列长度
#define SEVER_PORT 13442 // 端口 
/*套接字初始化*/ 
int StartUp()
{
    WORD w_version = MAKEWORD(2, 2);
    WSADATA wsa_data;
    int res = WSAStartup(w_version, &wsa_data);
    if (res != 0)
    {
    	printf("WSAStartup Error:%d\n",WSAGetLastError());
        return -1;
    }//版本号错误 
    if (LOBYTE(wsa_data.wVersion) != 2 || HIBYTE(wsa_data.wVersion) != 2)
    {
       	printf("WSAStartup Error:%d\n",WSAGetLastError());
        WSACleanup();
        return -1;
    }

    return 0; //成功返回0 
}
/*释放资源*/ 
int cleanUp()
{
    int res = WSACleanup();
    if (res == SOCKET_ERROR)
    {
    	printf("WSACleanup Error:%d",WSAGetLastError()); 
        return -1;
    }
    return 0;
}
/*断开连接，释放资源*/ 
int closeConn(SOCKET sock_conn)
{
    int res = closesocket(sock_conn); //关闭连接
    if (res == SOCKET_ERROR)
    {
    	printf("关闭连接失败%d\n",WSAGetLastError());
        return -1;
    }
    res = cleanUp();
    return res;
}
/*服务器初始化*/ 
SOCKET udpServerInit(int port)
{
    int res = -1;
    SOCKET sock_listen;
    const int on = 1;

    // 绑定地址、端口
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(port);

    //创建监听套接字
    sock_listen = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock_listen == INVALID_SOCKET)
    {
    	
       	printf("WSAStartup Error:%d\n",WSAGetLastError());
       	cleanUp();
        return -1;
    }

    //绑定服务器地址
    res = bind(sock_listen, (struct sockaddr *)&server_addr, sizeof(server_addr));
    if (res == SOCKET_ERROR)
    {
    	printf("绑定失败:%d\n",WSAGetLastError());
        closeConn(sock_listen);
        return -1;
    }

    return sock_listen;
}
/*子线程，线程函数*/
void* ThreadUdpEchoServer(LPVOID pParam){
    // 此处利用指针的移动 实现添加Echo
    int sock_res;
    char recv_data[MAXLINE];
    struct sockaddr_in client_addr;
    int addr_len = sizeof(client_addr);
    // 将输入参数转换成连接套接字
    SOCKET sock_conn = *((SOCKET *) pParam);
    do {
        memset(recv_data, 0, MAXLINE);
        // 接收数据
        sock_res = recvfrom(sock_conn, recv_data, MAXLINE, 0, (SOCKADDR *) &client_addr, &addr_len);
        if (sock_res > 0) {
			printf("从客户端接收到的数据：%s\n",recv_data);
            // 回射接收的数据
            sock_res = sendto(sock_conn, recv_data, sock_res, 0, (SOCKADDR *) &client_addr, addr_len);
            if (sock_res == SOCKET_ERROR) {
				printf("sendto error:%d\n",WSAGetLastError());
                sock_res = -1;
            } else {
				printf("发送出的数据：%s\n",recv_data);
				}
        } else {
			printf("recvfrom error:%d\n",WSAGetLastError());
            sock_res = -1;
        }
    } while (sock_res > 0);

    // 出错，继续其他客户端请求
    if (sock_res == -1) puts("此用户连接出错，继续下一个连接...");
    return NULL;
}
/*并发服务器*/
int UdpServer(SOCKET sock_conn){
    int sock_res;
    char recv_data[MAXLINE];
    struct sockaddr_in client_addr;
    int addr_len = sizeof(client_addr);
    SOCKET sock_child;
    struct sockaddr_in server_addr;
    const int on = 1;
    HANDLE hThread;

    do {
        memset(recv_data, 0, MAXLINE);
        // 接收数据
        sock_res = recvfrom(sock_conn, recv_data, MAXLINE, 0, (SOCKADDR *) &client_addr, &addr_len);
        if (sock_res > 0) {
			printf("接收到的数据：%s\n",recv_data);
            // 回射接收的数据

            // 创建一个新的socket
            // 设置地址、端口
            memset(&server_addr, 0, sizeof(server_addr));
            server_addr.sin_family = AF_INET;
            server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
            server_addr.sin_port = 0;
            //创建套接字
            sock_child = socket(AF_INET, SOCK_DGRAM, 0);
            // 创建失败
            if (sock_child == INVALID_SOCKET) {
				printf("sock_child error:%d\n",WSAGetLastError());
                cleanUp();
                return -1;
            }
            
            //绑定服务器地址
            sock_res = bind(sock_child, (struct sockaddr *) &server_addr, sizeof(server_addr));
            if (sock_res == SOCKET_ERROR) {
                printf("bind error:%d\n",WSAGetLastError());
                closeConn(sock_child);
                return -1;
            }

            // 获取端口号
            struct sockaddr_in temp_conn;
            int temp_len = sizeof(temp_conn);
            sock_res = getsockname(sock_child, (SOCKADDR*)&temp_conn, &temp_len);
            if (sock_res != 0){
                puts("getsockname error");
                return -1;
            }
            int port = ntohs(temp_conn.sin_port);
            memset(recv_data, 0, MAXLINE);
            itoa(port, recv_data, 10);

            sock_res = sendto(sock_conn, recv_data, (int)strlen(recv_data), 0, (SOCKADDR *) &client_addr, addr_len);
            if (sock_res == SOCKET_ERROR) {
                printf("sendto error:%d\n",WSAGetLastError());
                sock_res = -1;
            } else {
				printf("发送出的数据：%s\n",recv_data);
				hThread=CreateThread(NULL,0,ThreadUdpEchoServer,&sock_child,0,NULL);
                return 0;
            }
        } else {
			printf("recvfrom error:%d\n",WSAGetLastError());
            sock_res = -1;
        }
    } while (sock_res > 0);

    // 出错，继续其他客户端请求
    if (sock_res == -1) 
	{
		CloseHandle(hThread);
		puts("此用户连接出错，继续下一个连接...");
	}
    return 0;
}
int main(int argc, char *argv[]) {
    int sock_res;
    SOCKET sock_listen;
	HANDLE hThread;

    if (StartUp() == -1) return -1;  // 启动
    sock_listen = udpServerInit(SEVER_PORT);  //监听
    if (sock_listen == -1) return -1;
	puts("udpServerInit success");
    while (1) {
        sock_res = UdpServer(sock_listen);
        // 出错，继续其他客户端请求
        if (sock_res == -1) puts("此用户连接出错，继续下一个连接...");
    }
	CloseHandle(hThread);
    // 关闭监听服务
    closeConn(sock_listen);
    return 0;
}

客户端代码（并发服务器对应的）

//回射程序，并发服务器对应的客户端
#define NETWORK1_2_1_A_COMM_H
#define NETWORK1_2_1_A_COMM_H
#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
#include <inaddr.h>
#include <time.h>
#include <string.h>
#pragma comment(lib, "ws2_32.lib")
#define MAXLINE 4096     // 接收缓冲区长度
#define LISTENQ 1024     // 监听队列长度
#define SEVER_PORT 13442 // 端口 
char server_ip[] = "10.236.10.200"; 
/*套接字初始化*/ 
int StartUp()
{
    WORD w_version = MAKEWORD(2, 2);
    WSADATA wsa_data;
    int res = WSAStartup(w_version, &wsa_data);
    if (res != 0)
    {
    	printf("WSAStartup Error:%d\n",WSAGetLastError());
        return -1;
    }//版本号错误 
    if (LOBYTE(wsa_data.wVersion) != 2 || HIBYTE(wsa_data.wVersion) != 2)
    {
       	printf("WSAStartup Error:%d\n",WSAGetLastError());
        WSACleanup();
        return -1;
    }

    return 0; //成功返回0 
}
/*释放资源*/ 
int cleanUp()
{
    int res = WSACleanup();
    if (res == SOCKET_ERROR)
    {
    	printf("WSACleanup Error:%d",WSAGetLastError()); 
        return -1;
    }
    return 0;
}
/*断开连接，释放资源*/ 
int closeConn(SOCKET sock_conn)
{
    int res = closesocket(sock_conn); //关闭连接
    if (res == SOCKET_ERROR)
    {
    	printf("关闭连接失败%d\n",WSAGetLastError());
        return -1;
    }
    res = cleanUp();
    return res;
}
int getline(char s[],int lim)
{
    int c,i;
    i=0;
    while((c=getchar())!=EOF&&c!='\n'&&i<lim-1)
        s[i++]=c;
    s[i]='\0';
    return i;
}
/*回射客户端发送接收程序*/
int udpEchoClient(SOCKET sock_conn, SOCKADDR *server_addr, int addr_len)
{
    int res = -1;
    char send_data[MAXLINE], recv_data[MAXLINE];
    memset(send_data, 0, MAXLINE);
    memset(recv_data, 0, MAXLINE);
	 
    while (getline(send_data, MAXLINE))//输入缓冲区接收一行数据 
    {
        // 结束
        if (*send_data == 'Q' || *send_data == 'q')
        {
            puts("退出"); 
            return 0; // 正常退出
        }
        // 发送数据
        res = sendto(sock_conn, send_data, (int)strlen(send_data), 0, (SOCKADDR *)server_addr, addr_len);
        if (res == SOCKET_ERROR)
        {
        	printf("发送失败：%d\n",WSAGetLastError());
            return -1;
        }
		printf("发送数据：%s\n",send_data); 
        // 接收数据
        res = recvfrom(sock_conn, recv_data, MAXLINE, 0, NULL, NULL);
        if (res > 0)
        {
        	printf("接收到的数据:%s\n",recv_data);
        }
        else
        {
            printf("接收失败：%d\n",WSAGetLastError());
            break;
        }

        // 清空缓存
        memset(recv_data, 0, MAXLINE);
        memset(send_data, 0, MAXLINE);
    }
    return res;
}
/*连接服务器并绑定*/
SOCKET udpClientInit(char *server_ip, u_short port, sockaddr_in &server_addr, bool flag)
{
    int res = -1;
    SOCKET sock_conn;
    // 绑定地址、端口
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(port);
    server_addr.sin_addr.S_un.S_addr = inet_addr(server_ip);
    //创建套接字
    sock_conn = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock_conn == INVALID_SOCKET)
    {
    	printf("连接初始化失败%d\n",WSAGetLastError());
        cleanUp();
        return -1;
    }

    if (flag)
    {
        // 请求连接服务器
        res = connect(sock_conn, (struct sockaddr *)&server_addr, sizeof(server_addr));
        if (res == SOCKET_ERROR)
        {
            // 连接服务器失败
            printf("连接失败：%d\n",WSAGetLastError()); 
            closeConn(sock_conn);
            return -1;
        }
    }

    return sock_conn; //连接成功
}

/*对应并发服务器，客户端请求新端口函数*/
int UdpClientAskNewPort(SOCKET sock_conn, sockaddr_in server_addr, int addr_len){
    int sock_res;
    char send_data[MAXLINE] = "ASK port", recv_data[MAXLINE];
    memset(recv_data, 0, MAXLINE);

    while (1) {
        sock_res = sendto(sock_conn, send_data, (int) strlen(send_data), 0, (SOCKADDR *)&server_addr, addr_len);
        if (sock_res == SOCKET_ERROR) {
			printf("ASK port send error:%d\n",WSAGetLastError());
            return -1;
        }

        memset(recv_data, 0, MAXLINE);
        sock_res = recvfrom(sock_conn, recv_data, MAXLINE, 0, NULL, NULL);

        if (sock_res > 0) {
			printf("Requset :接收到的新端口号为：%s\n",recv_data);
			//客户端重新连接
            sock_conn = udpClientInit(server_ip, (u_short) atoi(recv_data), server_addr, true);
            if (sock_conn == -1) 
			{
				puts("客户端重新连接新端口失败");
				return -1;
			}
            sock_res = udpEchoClient(sock_conn, (SOCKADDR *)&server_addr, addr_len);
            if (sock_res == -1) puts("客户端连接失败");
            closeConn(sock_conn);

            break;
        } else {
			printf("recv error:%d\n",WSAGetLastError());
            return -1;
        }
    }

    return 0;
}

int main() {
    int sock_res;
    SOCKET sock_conn;
    sockaddr_in server_addr;
    
    if (StartUp() == -1) return -1;  // 启动
    sock_conn = udpClientInit(server_ip, SEVER_PORT, server_addr, true);  //连接
    if (sock_conn == -1) return -1;
    // 连接服务器成功
	puts("客户端启动");
    sock_res = UdpClientAskNewPort(sock_conn, server_addr, sizeof(sockaddr_in));
    if (sock_res == -1) puts("连接失败");
    closeConn(sock_conn);
    return sock_res;
}

三、用户使用说明（输入 / 输出规定）

对回射服务器和客户端（循环服务器以及并发服务器）：

  1. 对于服务器端程序，用户无需输入，服务器端程序会自动输出接收到的数据以及每次发送给客户端的数据，若函数调用出现错误，会显示文字（例如:“连接失败”）并显示 WSAGetLastError()返回的错误号。
  2. 对于客户端程序，运行后当显示“连接服务器成功”后，用户可输入发给服务器的内容，回车就会发送，当输入“Q”或“q”时会断开连接。
  3. 对客户端程序，每当发送完数据后，屏幕会显示从服务器端接收到的数据

四、运行结果

回射程序，客户端和循环服务器运行结果

在这里插入图片描述

回射程序，客户端和并发服务器运行结果

在这里插入图片描述

20230921
关注
  • 2
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
回射程序（客户端）——客户接收一行数据
小屁豪的专栏
04-09 2348
基于流式套接字的服务器回射程序设计。 编写一服务器程序和客户程序，要求客户每输入一行数据，服务器接收后加上echo:回送给客户程序，当客户输入“q”后退出。
Windows网络编程（TCP流式套接字实验）
breaver
03-06 2499
一、 实验环境 Windows10 vs2017 c/c++ 二、实验内容 1.设计思路 基于流式套接字的时间同步服务器设计 要求使用流式套接字编程，实现时间同步服务器和客户端，该服务器能够接收客户端的查询请求，获取本地时间，并将结果发送回客户端，客户端将该时间显示出来，如图1所示。 (1) time()函数、ctime()函数为时间处理函数。 (2)客户的recv函数需要循环接收。 ...
基于数据报套接字的服务器回射程序设计_套接字Socket的常见面试题及答案
weixin_39836726的博客
11-22 199
1. 对套接字编程的理解，它的协议是如何的？socket通常称为“套接字”，用于描述IP地址和端口，是一个通信链的句柄。应用程序通过套接字向网络发出请求或应答网络请求。服务器和客户端通过socket进行交互。服务器需要绑定在本机的某个端口号上，客户端需要声明自己连接哪个地址的哪个端口，这样服务器和客户端就能连接了。根据连接启动的方式以及本地套接字要连接的目标，套接字之间的连接过程可以分为三个步骤：...
UNIX网络编程---TCP客户/服务器程序示例（五）
jishublog
09-18 173
一、概述 下面的简单的例子是执行如下步骤的一个回射服务器： 1）客户从标准输入读入一行文本，并写给服务器 2）服务器从网络输入读入这行文本，并回射给客户 3）客户从网络输入读入这行回射文本，并显示在标准输出上 在客户和服务器之间画了两个箭头，不过他们实际上构成一个全双工的TCP链接。fgets和fputs这两个函数来自标注I/O函数库，writen和readline这两个函数是...
计算机网络-Echo实验（附源码）
wangxiaoxie424的博客
04-10 1974
【实验题目】Echo实验 【实验目的】掌握套节字的基本使用方法。 【实验内容】 (1)编写TCP Echo程序 实验要求： 服务器把客户端发送来的任何消息都返回给客户端，返回的消息前面要加上服务器的当前时间。客户端把返回的消息显示出来。客户端每输入一条消息就建立TCP连接，并把消息发送给服务器，在收到服务器回应后关闭连接。 1、只运行客户端程序而不运行服务器程序会出现什么错误，截屏说明原因。 客...
第讲-服务器软件设计的算法和问题优秀文档.ppt
最新发布
11-14
在编程过程中，服务器需要创建套接字并绑定到特定端口，如使用`bind`函数。当有新的连接请求时，服务器会调用`accept`来接收，然后创建新的线程或进程处理请求。在多接口主机上，`INADDR_ANY`可以用于匹配任何IP地址...
MySQL服务器连接过程浅析
09-10
同时，还有一个`struct st_vio`结构体，它作为数据传输的中介，负责从网络套接字读取并处理通信内容。 一旦客户端的连接被处理，`THD`变量会通过`create_thread_to_handle_connection()`函数传递到一个服务线程，...
基于Linux的多协议多服务服务器程序设计.pdf
09-07
文章中给出了多协议多服务服务器程序的实现框架，这通常包括初始化阶段（创建套接字，设置监听）、主循环（使用select进行等待和处理就绪事件）和响应阶段（根据事件类型进行相应的处理，如accept、recvfrom、sendto...
Python网络编程之TCP套接字简单用法示例
09-20
Python网络编程中的TCP套接字是网络通信的基础，它提供了可靠的数据传输服务，适用于需要保持连接状态的应用场景，如文件传输、远程登录等。在Python中，我们可以使用内置的`socket`模块来实现TCP套接字编程。下面将...
Linux下预创建线程并发网络服务器的两种实现方法.pdf
09-07
当`accept`函数返回一个新的套接字句柄时，说明有新的连接请求，线程可以立即开始处理该连接，而无需等待其他线程创建新线程。这种方式可以有效地并行处理多个连接请求，提高了服务器的并发能力。 每种线程创建策略...
udp客户服务器端回射完整例子
04-14
《unix网络编程》第八章8.1例子，使用UDP套接字开发的最简单的客户服务器例子
初识Socket编程——基于数据报套接字的服务器回射程序设计
姑苏流白
01-11 2501
实验四、基于数据报套接字的服务器回射程序设计 0x00 实验内容 编写一服务器程序和客户程序，要求客户每输入一行数据，服务器接收后加上 &quot;Echo:&quot; 后回送给客户程序，当客户输入“q”后退出。过程描述如下： UserUDP ClientUDP ServerInput Datasendto --- recvfromrecvfrom --- sendtoOutput DataUserUDP Clie...
Socket基础三：基于流式套接字的网络程序（服务器回射程序设计)
qq_44807456的博客
04-27 2489
作者：刘磊 2020.4.27 　　　参考书目：《Windows网络编程》刘琰等著 回射程序 回射程序是进行网络诊断的常用工具之一，例如Ping是windows系统下自带的可执行命令，利用它可以检查网络是否连通，不过ping是网络层上的，不适合传输层的应用程序测试和诊断。 基本执行步骤 服务器： 引用头文件 创建流式套接字 捆绑服务器的指定端口到套接字 把套接...
基于数据报套接字的服务器回射程序设计_Linux C Http 文件服务器实现（含源码）...
weixin_39641450的博客
11-19 200
整体思路： 创建socket监听请求，收到请求后线程分离，在线程中进行请求数据的解析；根据解析到的消息我们分类处理，目前该文件服务器可提供的文件包括html、css、jpg、gif；1.监听请求,； 首先设置了端口复用，这个从字面理解就好了，就是说该端口上可以绑定多个socket；分配套接字，Http文件服务器是基于TCP传输协议； 初始化监听的地址结构体； 套接字与地址结构体绑定；2.循环监听，...
Socket基础四：基于流式套接字的网络程序（并发服务器设计）
qq_44807456的博客
05-01 1073
作者：刘磊 2020.4.27 　　　参考书目：《Windows网络编程》刘琰等著 一、并发性 并发性是TCP/IP程序的基础，服务器软件必须在程序中有专门的支持并发的硬件或专门的机制实现并发处理。 ...
Socket基础七：基于原始套接字的网络程序（服务器回射程序设计）
qq_44807456的博客
01-13 713
Socket基础五：基于数据报套接字的网络程序（服务器回射程序设计） 作者：刘磊 2020.4.27 　　　参考书目：《Windows网络编程》刘琰等著 一、原始套接字 原始套接字是一种允许访问底层传输协议的套接字类型，能够对网络数据包进行某种程度的控制操作，此类套接字通常用于开发简单网络性能监视程序以及网络探测、网络攻击等工具。 在网络层上，原始套接字基于不可靠的IP分组传输服务，与数据报套接字类似，特点是无连接、不可靠。 二、功能函数 1、SOCKET raw_socket(BOOL bSendflag
Socket编程 ——UDP 实验报告
4ct10n
12-10 5776
一 客户端数据反射交互（1）实验内容要求：利用数据报套接字实现数据传输 客户端创建UDP套接字，向指定的服务端发送数据； 服务端接收到新数据，显示是谁发送过来的，并把该数据回传给发送方； 服务端使用多线程来实现并发 （2）实现方法Clientunsigned int port; char recvData[255]; cin >> sendData; sendto(scli
《unix网络编程》（18）基本UDP套接字 简单客户服务器回射程序及改进
Sunshine的专栏
04-14 1934
基本TCP套接字参考《unix网络编程》（8）基本TCP套接字 套接字函数 #include #include ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *addrlen); ssize_t
recvline定长数据接收 ：回射程序，客户端使用 recvline 接收一行数据【基于流式套接字的网络程序设计】
一只猫猫的博客
12-01 1334
实验环境：Dev-C++ recvline定长数据接收 回射程序，客户端使用 recvline 接收一行数据 目录设计思路recvline,回射程序，服务器端recvline 回射程序，客户端 设计思路 用 recv 接收一个字节，然后判断是否为\n，然后写到缓冲区里 recvline,回射程序，服务器端
第四章-套接字编程-04271
08-03
第四章 套接字编程:copyright: 电子科技大学信息与软件工程学院计算机网络课程组, 2020学习目的学习目的1. 掌握字节序、内存对齐等计算机网络编程相关基础知识2. 理解

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

20230921

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值