recvline定长数据接收 ：回射程序，客户端使用 recvline 接收一行数据【基于流式套接字的网络程序设计】

实验环境：Dev-C++

recvline定长数据接收
回射程序，客户端使用 recvline 接收一行数据

设计思路

用 recv 接收一个字节，然后判断是否为\n，然后写到缓冲区里

recvline,回射程序，服务器端

//回射程序， 服务器

#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 13131 // 端口
#define LEN 1
//初始化动态连接库 
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("版本号错误：%d\n",WSAGetLastError()); 
        WSACleanup();
        return -1;
    }

    return 0; //WSAStartup()成功
}
/*释放动态连接库*/
int cleanUp()
{
    int res = WSACleanup();
    if (res == SOCKET_ERROR)
    {
    	printf("WSACleanup error:%d\n",WSAGetLastError());
        return -1;
    }
    return 0;
}
/*断开连接并释放资源*/
int closeConn(SOCKET sock_conn)
{
    int res = closesocket(sock_conn); //关闭连接
    if (res == SOCKET_ERROR)
    {
    	printf("close socket error:%d",WSAGetLastError());
        return -1;
    }
    res = cleanUp();
    return res;
}
/*Server Init*/
SOCKET tcpServerInit(u_short port)
{
    int res = -1;

    // 设置地址
    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);

    //创建流式套接字
    SOCKET sock_listen = socket(AF_INET, SOCK_STREAM, 0);
    if (sock_listen == INVALID_SOCKET)
    {
    	printf("Sock error:%d",WSAGetLastError());
        WSACleanup();
        return -1;
    }

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

    //设置服务器为监听状态 最长长度LISTENQ
    res = listen(sock_listen, LISTENQ);
    if (res == SOCKET_ERROR)
    {
    	printf("listen error:%d\n",WSAGetLastError());
        closeConn(sock_listen);
        return -1;
    }

    return sock_listen;
}
/*回射服务器*/
int tcpEchoServer(SOCKET sock_conn)
{
    int res=-1;
    char recv_data[MAXLINE + 1];
	char HUICHE[3]="\n";
    do
    {
        // 清空接收缓存
        memset(recv_data, 0, MAXLINE);

        // 接收数据
        res = recv(sock_conn, recv_data, MAXLINE, 0);
        if (res > 0)
        {
        	printf("接收到的数据：%s\n",recv_data); 
            // 回射接收的数据
            res = send(sock_conn, recv_data, res, 0);
            send(sock_conn,HUICHE,1,0);
            if (res == SOCKET_ERROR)
            {
            	printf("send error:%d\n",WSAGetLastError());
                res = -1;
            }
            else
            {
            	printf("发送数据：%s\n",recv_data);
            }
        }
        else
        {
            if (res == 0)
            {
            	puts("Client closed!");
            }
            else
            {
            	printf("revc error:%d\n",WSAGetLastError());
                res = -1;
            }
            break;
        }
    } while (res > 0);

    return res;
}
int main(int argc, char *argv[])
{
    int res = -1;
    char buff[MAXLINE]; //缓冲区
    SOCKET sock_conn;
    SOCKET sock_listen;

    // 启动
    res = startUp();
    if (res == -1) return -1;

    //监听
    sock_listen = tcpServerInit(SEVER_PORT);
    if (sock_listen == -1) return -1;
	puts("Server  StartUp seccess!");

    // 循环服务器
    while (true)
    {
        //接受客户端连接请求  建立连接
        sock_conn = accept(sock_listen, NULL, NULL);

        if (sock_conn != INVALID_SOCKET)
        {
        	puts("连接成功");
            res = tcpEchoServer(sock_conn);
            if (res == -1)
            {
            	puts("连接失败");
            }
        }
        else
        {
        	printf("Accept Error:%d\n",WSAGetLastError());
            closeConn(sock_listen);
            return -1;
        }

        if (closesocket(sock_conn) == SOCKET_ERROR)
        {
        	printf("close error:%d\n",WSAGetLastError());
        }
    }

    // 关闭连接
    closeConn(sock_listen);
    return 0;
}

recvline 回射程序，客户端

// 回射程序，send ,recvline 客户端

#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 13131 // 端口
char recv_data[MAXLINE];
//初始化动态连接库 
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("版本号错误：%d\n",WSAGetLastError()); 
        WSACleanup();
        return -1;
    }

    return 0; //WSAStartup()成功
}
/*释放动态连接库*/
int cleanUp()
{
    int res = WSACleanup();
    if (res == SOCKET_ERROR)
    {
    	printf("WSACleanup error:%d\n",WSAGetLastError());
        return -1;
    }
    return 0;
}
/*断开连接并释放资源*/
int closeConn(SOCKET sock_conn)
{
    int res = closesocket(sock_conn); //关闭连接
    if (res == SOCKET_ERROR)
    {
    	printf("close socket error:%d",WSAGetLastError());
        return -1;
    }
    res = cleanUp();
    return res;
}
/*客户端套接字初始化*/
SOCKET tcpClientInit(char *server_ip, u_short port)
{
    int res;
    SOCKET sock_conn;

    // 设置服务器地址
    sockaddr_in server_addr;
    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_STREAM, 0);
    if (sock_conn == INVALID_SOCKET)
    {
    	printf("socket error:%d\n",WSAGetLastError());
        cleanUp();
        return -1;
    }

    // 请求连接服务器
    res = connect(sock_conn, (sockaddr *)&server_addr, sizeof(server_addr));
    if (res == SOCKET_ERROR)
    {
    	printf("connect error:%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;
}

//读取一行数据
BOOL	RecvLine(SOCKET s, char* buf)
{
	BOOL	retVal = 1;			//返回值
	BOOL	bLineEnd = 0;		//行结束
	int		nReadLen = 0;			//读入字节数
	int		nDataLen = 0;	//数据长度
	while (!bLineEnd)	//没有换行
	{
		nReadLen = recv(s, buf + nDataLen, 1, 0);//每次接收一个字节		
		//错误处理
		if (SOCKET_ERROR == nReadLen)
		{			
			retVal= -1;	//读数据失败
			printf("recv error：%d\n",WSAGetLastError());
			break;			//跳出循环						
		}		
		
		if (0 == nReadLen)//客户端关闭
		{
			puts("关闭连接");
			retVal = -1;	//读数据失败
			break ;			//跳出循环			
		}
		
		//读入数据
		if ('\n' == *(buf + nDataLen))	//换行符
		{
			bLineEnd = 1;			//接收数据结束
		}else{
			nDataLen += nReadLen;		//增加数据长度
		}	
	}
	
	return retVal;
}


/*tcp发送接收*/
int tcpEchoClient(SOCKET sock_conn)
{
    int res = 0;
    char send_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("结束发送");

            // 关闭发送
            res = shutdown(sock_conn, SD_SEND);
            if (res == SOCKET_ERROR)
            {
            	printf("shutdow error:%d\n",WSAGetLastError());
            }
            return 0;//正常返回 
        }

        // 发送数据
        res = send(sock_conn, send_data, (int)strlen(send_data), 0);
        if (res == SOCKET_ERROR)
        {
        	printf("send error:%d\n",WSAGetLastError());
            return -1;
        }
		printf("发送出去的数据是：%s\n",send_data);
		
		res=RecvLine(sock_conn, recv_data);
		if(res==-1)
		{
			puts("发送失败");
			break;
		}
		printf("接收到的数据：%s\n",recv_data);
        // 清空缓存
        memset(recv_data, 0, MAXLINE);
        memset(send_data, 0, MAXLINE);
    }
    return res;
}
int main()
{
    int res = -1;
    SOCKET sock_conn;
    char server_ip[] = "10.236.10.200";

    // 启动
    res = startUp();
    if (res == -1) return -1;
    //连接
    sock_conn = tcpClientInit(server_ip, SEVER_PORT);
    if (sock_conn == -1) return -1;
	puts("Client Startup seccess!");
    res = tcpEchoClient(sock_conn);  //处理连接
    closeConn(sock_conn);            //关闭连接

    return res;
}

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

客户端输入要发送的消息然后回车即可，屏幕会显示从服务器收到的数据。客户端输入 Q 或 q 断开连接。服务器端显示接收到的数据，以及回射给客户端的数据。

运行结果

recvline 回射程序，客户服务器端：