tcp套接字编程

于 2019-07-27 16:33:39 发布
阅读量222 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43581695/article/details/97264310
版权

1.tcp协议：传输控制协议---面向连接，传输可靠，面向字节流。

实现数据可靠传输，传输灵活但是会造成数据粘包问题。

2.tcp客户端与服务端通信流程

 

3.代码实现

//客户端

  1 #include"tcpsocket.hpp"
  2 #include<signal.h>
  3 
  4 void sigcb(int signo)
  5 {
  6     printf("connection closed\n");
  7 } 
  8         
  9 int main(int argc, char* argv[])
 10 {       
 11     if(argc != 3)
 12     {  
 14         return -1;
 15     } 
 16     std::string ip = argv[1];
 17     uint16_t port = atoi(argv[2]); 
 18 
 19     signal(SIGPIPE, sigcb);
 20     TcpSocket sock; 
 21     CHECK_RET(sock.Socket());  
 22     CHECK_RET(sock.Connect(ip, port));
 23     while(1)
 24     { 
 25         std::string buf;
 26         std::cout<<"client say: ";
 27         fflush(stdout);
 28         std::cin>>buf;
 29         sock.Send(buf);
 30         buf.clear();
 31         sock.Recv(buf);
 32         std::cout<<"server say: "<<buf<<std::endl;
 33     }
 34     sock.Close();
 35     return 0;
 36 }

//服务端

  1 #include"tcpsocket.hpp"
  2 int main(int argc, char* argv[])
  3 {
  4     if(argc != 3)
  5     {
  7         return -1;
  8     }
  9     std::string ip = argv[1];
 10     uint16_t port = atoi(argv[2]);
 11     TcpSocket sock;
 12 
 13     CHECK_RET(sock.Socket());
 14     CHECK_RET(sock.Bind(ip, port));
 15     CHECK_RET(sock.Listen());
 16     while(1)
 17     {
 18         TcpSocket clisock;
 19         std::string cliip;
 20         uint16_t cliport;
 21         if(sock.Accept(clisock, cliip, cliport) == false)
 22         {
 23             continue;
 24         }
 25 
 26         std::cout<<"new client: "<<cliip<<":"<<cliport<<std::endl;
 27         while(1)
 28         {
 29         std::string buf;
 30         clisock.Recv(buf);
 31         std::cout<<"client say: "<<buf<<std::endl;
 32         buf.clear();
 33         std::cout<<"server say: ";
 34         fflush(stdout);
 35         std::cin>>buf;
 36         clisock.Send(buf);
 37         }
 38     }
 39     sock.Close();
 40     return 0;
 41 }

 

//封装好各个函数的头文件

  1 #include<iostream>
  2 #include<stdio.h>
  3 #include<string>
  4 #include<unistd.h>
  5 #include<stdlib.h>
  6 #include<errno.h>
  7 #include<netinet/in.h>
  8 #include<arpa/inet.h>
  9 #include<sys/socket.h>
 10 #define CHECK_RET(q) if((q) == false) { return -1;}
 11 
 12 class TcpSocket
 13 {
 14     public:
 15         TcpSocket(){}
 16         ~TcpSocket(){}
 17         bool Socket()
 18         {
 19             _socketfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 20             if(_socketfd < 0)
 21             {
 22                 perror("socket error");
 23                 return false;
 24             }
 25             return true;
 26         }
 27 
 28         bool Bind(std::string& ip, uint16_t port)
 29         {
 30             struct sockaddr_in addr;
 31             addr.sin_family = AF_INET;
 32             addr.sin_port = htons(port);
 33             addr.sin_addr.s_addr = inet_addr(ip.c_str());
 34 
 35             socklen_t len = sizeof(struct sockaddr_in);
 36             int ret = bind(_socketfd, (struct sockaddr*)&addr, len);
 37             if(ret < 0)
 38             {
 39                 perror("bind error");
 40                 return false;
 41             }
 42             return true;
 43         }
 44 
 45         bool Listen(int backlog = 5)
 46         {
 47             int ret = listen(_socketfd, backlog);
 48             if(ret < 0)
 49             {
 50                 perror("listen error");
 51                 return false;
 52             }
 53             return true;
 54         }
 55 
 56         bool Accept(TcpSocket &cli, std::string &cliip, uint16_t port)
 57         {
 58             struct sockaddr_in addr;
 59             socklen_t len = sizeof(struct sockaddr_in);
 60             int sockfd = accept(_socketfd, (struct sockaddr*)&addr, &len);
 61             if(sockfd < 0)
 62             {
 63                 perror("accept error");
 64                 return false;
 65             }
 66             cli.SetFd(sockfd);
 67             cliip = inet_ntoa(addr.sin_addr);
 68             port = ntohs(addr.sin_port);
 69             return true;
 70         }
 71 
 72         void SetFd(int sockfd)
 73         {
 74             _socketfd = sockfd;
 75         }
 76 
 77         bool Connect(std::string& srv_ip, uint16_t srv_port)
 78         {
 79             struct sockaddr_in addr;
 80             addr.sin_family = AF_INET;
 81             addr.sin_port = htons(srv_port);
 82             addr.sin_addr.s_addr = inet_addr(srv_ip.c_str());
 83             socklen_t len = sizeof(struct sockaddr_in);
 84 
 85             int ret = connect(_socketfd, (struct sockaddr*)&addr, len);
 86             if(ret < 0)
 87             {
 88                 perror("connect error");
 89                 return false;
 90             }
 91             return true;
 92         }
 93 
 94         bool Send(std::string &buf)
 95         {
 96             int ret = send(_socketfd, buf.c_str(), buf.size(), 0);
 97             if(ret < 0)
 98             {
 99                 perror("send error");
100                 return false;
101             }
102             return true;
103         }
104 
105         bool Recv(std::string &buf)
106         {
107             char temp[1024];
108             int ret = recv(_socketfd, temp, 1024, 0);
109             if(ret < 0)
110             {
111                 perror("recv error");
112                 return false;
113             }
114             buf.assign(temp, ret);
115             return true;
116         }
117 
118         bool Close()
119         {
120             close(_socketfd);
121             return true;
122         }
123     private:
124         int _socketfd;
125 
126 };

4.代码中的几个函数：

htons()：表示short型数据从主机字节序转到网络字节序。

h：host（主机）；    n：net（网络）；    s：short（短整型）/ l：long（长整型）

同理还有ntohs() 、htonl() 、htonl()。

inet_addr()：将字符串点分十进制转化成网络字节序IP地址。

inet_ntos()：将网络字节序转换成点分十进制形式IP地址。

listen()：声明socket处于监听状态，其第二个参数为允许的客户端最大并发连接数。

accept()：从已完成连接队列中获取一个客户端新建的已完成连接的socket，如果没有，则阻塞等待。

bind()：客户端没有调用bind()函数，因为如果在同一个机器上启动多个客户端，就会出现端口号被占用导致不能正确建立连接。

recv()：返回0时，一定是tcp断开连接，而不是传输数据大小为0，recv返回0，send触发异常。

 

5.使用上面的代码再启动一个客户端，尝试连接服务器，会发现第二个客户端不能正确与服务端通信，这是因为我们accept了一个请求之后，就一直在while循环尝试读取数据，没有继续调用accept导致不能接受新的请求。

所以使用多进程/多线程版本修改tcp的服务端程序即可。

//多进程版本服务端

#include <signal.h>
#include <sys/wait.h>
#include "tcpsocket.hpp"

void sigcb(int no){
    while(waitpid(-1, NULL, WNOHANG) > 0);
}
int main(int argc, char *argv[])
{
    if (argc != 3) {
        return -1;
    }
    std::string ip = argv[1];
    uint16_t port = atoi(argv[2]);

    signal(SIGCHLD, sigcb);

    TcpSocket sock;

    CHECK_RET(sock.Socket());
    CHECK_RET(sock.Bind(ip, port));
    CHECK_RET(sock.Listen());
    while(1) {
        TcpSocket clisock;
        std::string cliip;
        uint16_t cliport;
        if (sock.Accept(clisock, cliip, cliport) == false){
            continue;
        }
        std::cout<<"new client:"<<cliip<<":"<<cliport<<std::endl;

        int pid = fork();
        if (pid == 0) {
            while(1) {
                std::string buf;
                clisock.Recv(buf);
                std::cout<<"client say:"<<buf<<std::endl;

                buf.clear();
                std::cout<< "server say:";
                fflush(stdout);
                std::cin >> buf;
                clisock.Send(buf);
            }
            clisock.Close();
            exit(0);
        }
        //父进程一定要关闭这个套接字；因为父子进程数据独有
        //父进程关闭对子进程无影响；不关闭会造成资源泄漏
        clisock.Close();
    }
    sock.Close();
}

//多线程版本服务端

#include <pthread.h>
#include "tcpsocket.hpp"

void *thr_start(void *arg)
{
    TcpSocket *clisock = (TcpSocket*)arg;
    while(1) {
        std::string buf;
        clisock->Recv(buf);
        std::cout<<"client say:"<<buf<<std::endl;

        buf.clear();
        std::cout<< "server say:";
        fflush(stdout);
        std::cin >> buf;
        clisock->Send(buf);
    }
    clisock->Close();
    delete clisock;
    return NULL;
}

int main(int argc, char *argv[])
{
    if (argc != 3) {
        return -1;
    }
    std::string ip = argv[1];
    uint16_t port = atoi(argv[2]);

    TcpSocket sock;

    CHECK_RET(sock.Socket());
    CHECK_RET(sock.Bind(ip, port));
    CHECK_RET(sock.Listen());
    while(1) {
        TcpSocket *clisock = new TcpSocket();
        std::string cliip;
        uint16_t cliport;
        if (sock.Accept(*clisock, cliip, cliport) == false){
            continue;
        }
        std::cout<<"new client:"<<cliip<<":"<<cliport<<std::endl;

        pthread_t tid;
        pthread_create(&tid, NULL, thr_start, (void*)clisock);
        pthread_detach(tid);
    }
    sock.Close();
}

 在多线程版本中，由于在线程之间共享文件描述符，一个线程中打开的文件，另一个线程只要获取到这个文件的描述符，也可以对其进行操作。

 

 

qq_43581695
关注
TCP套接字编程
qizhihao123的博客
10-19 1232
TCP与UDP的区别相当大。它充分地实现了数据传输时的各种控制功能，可以进行丢包时重发控制，还可以对次序乱掉的分包进行顺序控制。而这些再UDP中都没有。此外，TCP作为一种面向有连接的协议，只要在确认通信对端存在时才会发生数据，从而可以控制通信流量的浪费。UDP不提供复杂的控制机制，利用IP提供面向无连接的通信服务。并且它是将应用程序发来的数据在收的那一刻，立即按照原样发送到网络上的一种机制。UDP是 User Datagram Protocol 的缩写，即用户数据报协议。
基于Python进行TCP套接字编程的基础知识 实验报告
01-08
进一步理解和掌握基于Python进行TCP套接字编程的知识，理解SMTP报文格式，能基于Python编写一个简单的SMTP客户端程序。 2实验条件 装有python环境的电脑两台 局域网环境 已经正常运行的邮件服务器 3实验报告内容及...
TCP_Socket.rar_tcp套接字编程
09-20
在IT行业中，网络编程是不可或缺的一部分，而TCP套接字编程是实现可靠网络通信的核心技术。TCP（Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议，广泛应用于互联网上的各种...
TCP 套接字编程计算机网络实验
最新发布
11-22
在TCP套接字编程实验中，我们主要关注的是如何利用TCP协议进行服务器和客户端之间的通信。TCP（Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议，具有以下特点： 1. **面向...
基于TCP的套接字编程
11-18
简单的socket程序，包括服务器端以及客户端程序，实现两主机之间基于TCP的文本消息的传输。
TCP套接字编程（C语言）
热门推荐
哆啦A瑶的博客
06-07 1万+
本篇主要内容介绍：介绍TCP套接字基本概念介绍TCP套接字编程流程基本TCP套接字函数介绍1、TCP套接字基本概念（非官方解释，个人总结）    套接字是一种网络API，提供一种进程间的通信方法，使得相同主机或者不同主机上的进程能够使用socket定义的规范进行双向的数据通信。进程之间调用套接字接口实现相互通信，套接字接口利用下层的网络通信协议功能和系统调用实现实际的通信工作（这一部分对于编程者是...
TCP套接字编程入门教程：服务器端详解
这篇文档提供了一套完整且易于理解的TCP套接字编程教程，对于想要学习网络编程，尤其是服务器端开发的初学者来说，是极好的学习资料。理解这些核心概念后，可以进一步探索UDP套接字的异步特性，以及如何在实际项目中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值