tcp常用网络接口 linux环境

于 2024-08-06 23:17:16 发布
阅读量429 收藏 10
点赞数 12
文章标签： tcp/ip linux 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gyc2727/article/details/140967727
版权

TCP（传输控制协议）网络通信是常见的网络应用形式，它提供了面向连接的、可靠的数据传输服务。TCP通信常用的接口主要包括以下几个方面：

常用接口

1. socket()

int socket(int domain, int type, int protocol);
  • 功能：打开一个网络通讯端口，并返回一个文件描述符（socket描述符）。
  • 参数：
    • domain：地址族，对于IPv4，指定为AF_INET。
    • type：套接字类型，对于TCP协议，指定为SOCK_STREAM，表示面向流的传输协议。
    • protocol：传输层协议类型，对于TCP，通常指定为0。
  • 返回值：成功时返回文件描述符（非负整数），失败时返回-1。

2. bind()

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
  • 功能：将套接字与特定的网络地址（IP地址和端口号）绑定。
  • 参数：
    • sockfd：由socket()返回的文件描述符。
    • myaddr：指向sockaddr结构体的指针，包含要绑定的地址和端口信息。
    • addrlen：地址结构体的长度。
  • 返回值：成功时返回0，失败时返回-1。

3. listen()

 int listen(int sockfd, int backlog);
  • 功能：使服务器端的套接字进入监听状态，准备接受客户端的连接请求。
  • 参数：
    • sockfd：服务器端的套接字描述符。
    • backlog：设置等待连接队列的最大长度。
  • 返回值：成功时返回0，失败时返回-1。

4. accept()

 int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
  • 功能：接受一个客户端的连接请求，并返回一个新的套接字描述符，用于与该客户端进行通信。
  • 参数：
    • sockfd：服务器端的监听套接字描述符。
    • addr：可选参数，用于存储客户端的地址信息。
    • addrlen：传入时表示addr的长度，传出时表示实际存储的客户端地址信息的长度。
  • 返回值：成功时返回新的套接字描述符，失败时返回-1。

5. connect()

 int connect(int sockfd, const struct sockaddr *addr,
                   socklen_t addrlen);
  • 功能：客户端调用，用于建立与服务器端的连接。
  • 参数：
    • sockfd：客户端的套接字描述符。
    • addr：指向服务器地址信息的sockaddr结构体指针。
    • addrlen：服务器地址结构体的长度。
  • 返回值：成功时返回0，失败时返回-1。

6. send() 和 recv()

 ssize_t recv(int sockfd, void *buf, size_t len, int flags);
 ssize_t send(int sockfd, const void *buf, size_t len, int flags);
  • 功能：
    • send()：用于向连接的套接字发送数据。
    • recv()：用于从连接的套接字接收数据。
  • 参数：
    • sockfd：套接字描述符。
    • buf：指向数据缓冲区的指针。
    • len：要发送或接收的数据长度。
    • flags：通常设置为0，表示默认行为。
  • 返回值：
    • 对于send()，成功时返回实际发送的字节数，失败时返回-1。
    • 对于recv()，成功时返回实际接收的字节数，如果连接已关闭且没有数据可读，则返回0，出错时返回-1。

7. close()

 int close(int fd);
  • 功能：关闭套接字，释放相关资源。
  • 参数：套接字描述符。
  • 返回值：成功时返回0，失败时返回-1。

回显打印（熟悉一下接口）

大致流程

TCP服务器端流程

  1. 创建套接字（socket）
  2. 绑定套接字（bind）
  3. 监听连接（listen）
  4. 接受连接（accept）
  5. 数据传输（send/recv）
  6. 关闭套接字（close）

TCP客户端流程

  1. 创建套接字（socket）
  2. 连接服务器（connect）
  3. 数据传输（send/recv）
  4. 关闭套接字（close）

代码

ServerMain.cpp 服务器的主函数

#include "TcpServer.hpp"
#include<memory>
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        std::cerr << "Usage: " << argv[0] << " local-port" << std::endl;
        exit(0);
    }
    uint16_t port = std::stoi(argv[1]);
    std::unique_ptr<Tcpserver> tsvr = std::make_unique<Tcpserver>(port);
    tsvr->Initserver();
    tsvr->Loop();
    return 0;
}

TcpServer.hpp  对Tcp操作分装

#pragma once
#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "InterAddr.hpp"
#include "Threadpool.hpp"
enum
{
    SOCKET_ERROR = 1,
    BIND_ERROR,
    LISTEN_ERROR
};
static const uint16_t gport = 8888;
static const int glisten = -1;
static const int gbacklog = 8;
using task_t = std::function<void()>;
class Tcpserver
{
public:
    Tcpserver(uint16_t port = gport)
        : _port(port), _listensockfd(glisten), _isrunning(false)
    {
    }
    void Initserver()
    {
        _listensockfd = ::socket(AF_INET, SOCK_STREAM, 0);
        if (_listensockfd < 0)
        {
            std::cout << "socket error" << std::endl;
            exit(SOCKET_ERROR);
        }
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(_port);
        local.sin_addr.s_addr = INADDR_ANY;
        if (bind(_listensockfd, (const sockaddr *)&local, sizeof(local)) < 0)
        {
            std::cout << "bind error" << std::endl;
            exit(BIND_ERROR);
        }
        if (::listen(_listensockfd, gbacklog) < 0)
        {
            std::cout << "listen error" << std::endl;
            exit(LISTEN_ERROR);
        }
        std::cout << "init success" << std::endl;
    }
    void Loop()
    {
        _isrunning = true;
        while (true)
        {
            struct sockaddr_in client;
            socklen_t len = sizeof(client);
            int sockfd = ::accept(_listensockfd, (struct sockaddr *)&client, &len);
            if (sockfd < 0)
            {
                std::cout << "accpet error" << std::endl;
                exit(1);
            }
            InterAddr addr(client);
            std::cout<<"get a new link, client info"<<addr.AddrStr()<<std::endl;
            task_t f = std::bind(&Tcpserver::Service, this, sockfd, addr);
            ThreadPool<task_t>::GetInstance()->Equeue(f);
        }
        _isrunning = false;
    }
    void Service(int sockfd, InterAddr addr)
    {
        while (true)
        {
            char buffer[1024];
            ssize_t m = ::read(sockfd, buffer, sizeof(buffer) - 1);
            if (m > 0)
            {
                buffer[m] = 0;
                std::string echoserver = "[server echo]#";
                echoserver += buffer;
                ::write(sockfd, echoserver.c_str(), echoserver.size());
            }
            else if (m == 0)
            {
                std::cout << "clent quit " << addr.AddrStr() << std::endl;
                break;
            }
            else
            {
                std::cout << "read error" << std::endl;
                exit(1);
            }
        }
        ::close(sockfd);
    }
    ~Tcpserver()
    {
    }

private:
    uint16_t _port;
    int _listensockfd;
    bool _isrunning;
};

InterAddr.hpp LockGuard.hpp Thread.hpp Threadpool.hpp （字节序和线程池）

//interaddr.hpp
#pragma once
#include <iostream>
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
class InterAddr
{
private:
    void ToHost(const struct sockaddr_in &addr)
    {
        port = ntohl(addr.sin_port);
        ip = inet_ntoa(addr.sin_addr);
    }

private:
    std::string ip;
    uint16_t port;
    struct sockaddr_in _addr;

public:
    InterAddr(const struct sockaddr_in &addr)
        : _addr(addr)
    {
        ToHost(addr);
    }
     bool operator == (const InterAddr &t)
    {
        return (this->ip == t.ip && this->port == t.port);
    }
    std::string Ip()
    {
        return ip;
    }
    uint16_t Port()
    {
        return port;
    }
    struct sockaddr_in Addr()
    {
        return _addr;
    }
    std::string AddrStr()
    {
        return ip + ":" + std::to_string(port);
    }
    ~InterAddr()
    {
    }
};

//LockGuard.hpp
#pragma once 
#include<pthread.h>
class LockGuard
{
private:
    /* data */
    pthread_mutex_t* _mutex;
public:
    LockGuard(pthread_mutex_t* mutex);
    ~LockGuard();
};

LockGuard::LockGuard(pthread_mutex_t* mutex):_mutex(mutex)
{
    pthread_mutex_lock(_mutex);
}

LockGuard::~LockGuard()
{
    pthread_mutex_unlock(_mutex);
}

//Thread.hpp
#pragma once
#include <iostream>
#include <string>
#include <pthread.h>
#include <functional>
namespace ThreadMoudle
{
    using func_t = std::function<void(const std::string &)>;
    class Thread
    {
    public:
        void Execute()
        {
            isrunning = true;
            _func(_name);
            isrunning = false;
        }

    public:
        Thread(const std::string name, func_t func)
            : _name(name), _func(func)
        {
        }
        static void *ThreadRoutine(void *args)
        {
            Thread *a = static_cast<Thread *>(args);
            a->Execute();
            return nullptr;
        }
        bool Start()
        {
            int n = pthread_create(&_tid, nullptr, ThreadRoutine, (void *)this);
            if (n != 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        std::string Status()
        {
            if (isrunning)
            {
                return "running";
            }
            else
            {
                return "stop";
            }
        }
        void Stop()
        {
            if (isrunning)
            {
                pthread_cancel(_tid);
                isrunning = false;
            }
        }
        void Join()
        {
            pthread_join(_tid, nullptr);
        }
        std::string Name()
        {
            return _name;
        }
        ~Thread()
        {
        }

    private:
        std::string _name;
        pthread_t _tid;
        bool isrunning;
        func_t _func;
    };

} 

//Threadpool.hpp
#pragma once
#include <iostream>
#include <unistd.h>
#include <string>
#include <vector>
#include <queue>
#include <functional>
#include "LockGuard.hpp"
#include "Thread.hpp"
using namespace ThreadMoudle;
static const int gdefaultnum = 5;
// pthread_mutex_t _fmtx=PTHREAD_MUTEX_INITIALIZER;
template <class T>
class ThreadPool
{
private:
    void LockQueue()
    {
        pthread_mutex_lock(&_mutex);
    }
    void UnlockQueue()
    {
        pthread_mutex_unlock(&_mutex);
    }
    void Wakeup()
    {
        pthread_cond_signal(&_cond);
    }
    void WakeupAll()
    {
        pthread_cond_broadcast(&_cond);
    }
    void Sleep()
    {
        pthread_cond_wait(&_cond,&_mutex);
    }
    bool IsEmpty()
    {
        return _task_queue.empty();
    }
    void HandlerTask(const std::string name)
    {
        while (1)
        {
            LockQueue();
            while (IsEmpty() && _isrunning)
            {
                sleep_thread_num++;
                Sleep();
                sleep_thread_num--;
            }
            if (IsEmpty() && !_isrunning)
            {
                UnlockQueue();
                break;
            }
            T t = _task_queue.front();
            // std::cout<<&t<<std::endl;
            _task_queue.pop();
            UnlockQueue();
            // LockGuard lockguard(&_fmtx);
            t();
        }
    }
    void Init()
    {
        func_t func = std::bind(&ThreadPool::HandlerTask, this, std::placeholders::_1);
        for (int i = 0; i < _thread_num; i++)
        {
            std::string name = "Thread-" + std::to_string(i + 1);
            _threads.emplace_back(name, func);
        }
    }
    void Start()
    {
        _isrunning = true;
        for (auto &threadd : _threads)
        {
            threadd.Start();
        }
    }
    ThreadPool(int thread_num = gdefaultnum)
        : _thread_num(thread_num), _isrunning(false), sleep_thread_num(0)
    {
        pthread_mutex_init(&_mutex, nullptr);
        pthread_cond_init(&_cond, nullptr);
    }

    ThreadPool(const ThreadPool<T> &) = delete;
    void operator=(const ThreadPool<T> &) = delete;

public:
    void Stop()
    {
        LockQueue();
        _isrunning = false;
        WakeupAll();
        UnlockQueue();
    }
    static ThreadPool<T> *GetInstance()
    {
        LockGuard lockguard(&_sig_mutex);
        if (_tp == nullptr)
        {
            _tp = new ThreadPool();
            _tp->Init();
            _tp->Start();
        }
        return _tp;
    }
    void Equeue(const T& in)
    {
        LockQueue();
        if (_isrunning)
        {
            _task_queue.push(in);
            if (sleep_thread_num > 0)
            {
                Wakeup();
            }
        }
        UnlockQueue();
    }
    ~ThreadPool()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond);
    }

private:
    int _thread_num;
    std::vector<Thread> _threads;
    std::queue<T> _task_queue;
    bool _isrunning;
    int sleep_thread_num;
    pthread_mutex_t _mutex;
    pthread_cond_t _cond;

    static ThreadPool<T> *_tp;
    static pthread_mutex_t _sig_mutex;
};

template <class T>
ThreadPool<T> *ThreadPool<T>::_tp = nullptr;
template <class T>
pthread_mutex_t ThreadPool<T>::_sig_mutex = PTHREAD_MUTEX_INITIALIZER;

ClienMain.cpp 客户端

#include <iostream>
#include <string>
#include <cstring>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include "InterAddr.hpp"
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        std::cerr << "Usage: " << argv[0] << "server-ip local-port" << std::endl;
        exit(0);
    }
    std::string serverip = argv[1];
    uint16_t port = std::stoi(argv[2]);
    int sockfd = ::socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        std::cerr << "socket error" << std::endl;
        exit(1);
    }
    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(port);
    if (::inet_pton(AF_INET, serverip.c_str(), &server.sin_addr.s_addr) <= 0)
    {
        std::cerr << "inet_pton error" << std::endl;
        exit(1);
    }
    if (::connect(sockfd, (const struct sockaddr *)&server, sizeof(server)) < 0)
    {
        std::cerr << "connect error" << std::endl;
        exit(1);
    }
    while (true)
    {
        std::string message;
        std::cout<<"Enter #";
        std::getline(std::cin,message);
        ::write(sockfd,message.c_str(),message.size());
        char buffer[1024];
        int n=::read(sockfd,buffer,sizeof(buffer));
       if(n > 0)
        {
            buffer[n] = 0;
            std::cout << buffer << std::endl;
        }
        else
        {
            break;
        }
    }
    ::close(sockfd);
    return 0;
}

gyc2727
关注
  • 12
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux——网络通信TCP通信常用的接口和tcp服务demo
m0_72433000的博客
02-14 1698
bind()函数的作用是为了让socket返回的描述符与端口号进行绑定在bind函数之前我们还需要做一个工作就是将我们的信息存入一个结构体sockaddr_in中,struct sockaddr *是一个通用指针类型,myaddr参数实际上可以接受多种协议的sockaddr结构体,而它们的长度各不相同,所以需要第三个参数addrlen指定结构体的长度。connect和bind的参数形式一致, 区别在于bind的参数是自己的地址, 而connect的参数是对方的地址;listen成功返回0 失败则是-1。
Linux网络编程系列之TCP协议编程
AABond的博客
10-06 1127
Linux网络编程系列之TCP，TCP的简单介绍和使用
Linux应用 TCP网络编程
cesheng3410的博客
03-25 1133
本文讲解了TCP的定义以及应用场景，列出了编程中常用的接口，最后编写程序进行测试
Linux网络编程之TCP/IP通信基础以及例程分享
qq_58288010的博客
12-19 1270
TCP/IP网络协议栈分为应用层（Application）、传输层（Transport）、网络层（Network）和链路层（Link）四层。应用层（Application Layer）：应用层是最靠近用户的一层，它提供了用户与网络之间的接口。在应用层，应用程序可以通过使用各种协议（如HTTP、FTP、SMTP等）来进行通信。应用层的主要任务是处理应用程序之间的通信和数据交换。传输层（Transport Layer）：传输层负责在网络中的两个主机之间提供可靠的端到端数据传输。
Linux网络——TcpServer
m0_75186846的博客
07-18 1456
基于上一篇套接字与UDP的博客，继续讲解了TCP服务，并着重讲解了两种服务的差异化，并进一步对TCP的服务端与客户端做了相应的通用封装。
Linux_TCP/IP_网络编程
潮与虎
11-21 2039
一句话，主要防止已经失效的连接请求报文突然又传送到了服务器，从而产生错误。​ 如果使用的是两次握手建立连接，假设有这样一种场景，客户端发送了第一个请求连接并且没有丢失，只是因为在网络结点中滞留的时间太长了，由于TCP的客户端迟迟没有收到确认报文，以为服务器没有收到，此时重新向服务器发送这条报文，此后客户端和服务器经过两次握手完成连接，传输数据，然后关闭连接。
Linux_socket(TCP篇)网络编程
Jalon
08-03 2068
tcp 协议是⾯向连接的协议，在实现 tcp 客户端时，则需要先连接服务器，后⾯才能进⾏通讯。
Linux基础-socket详解、TCP/UDP
weixin_37553721的博客
04-29 2706
所谓socket通常也称作 “套接字”，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过 “套接字” 向网络发出请求或者应答网络请求。Socket 是计算机网络编程中一个重要的概念，它是在应用层和传输层之间提供的一种抽象接口，用于实现应用程序之间的数据交换。Socket 允许程序员使用一种通用的接口来访问底层传输协议，如 TCP 和 UDP，以便进行网络通信。Socket 是一种编程接口，它提供了一种标准化的方式来创建网络连接，并允许应用程序在网络上发送和接收数据。
linux网络编程 -- tcp和udp通信的简单实现
m0_60292931的博客
07-12 1589
懒得写摘要
Linux 网络编程学习笔记——一、TCP/IP 协议族
热门推荐
BeZer0的学习笔记
03-20 1万+
数据链路层实现了网卡接口的网络驱动程序，以处理数据在物理媒介（以太网、令牌环等）上的传输，不同的物理网络具有不同的电气特性，网络驱动程序隐藏了这些细节，为上层协议提供一个统一的接口。最常用的协议是 ARP（Address Resolve Protocol，地址解析协议）和 RARP（Reverse Address Resolve Protocol），它们实现了 IP 地址和机器物理地址（通常是 MAC 地址）之间的相互转换。
tcp.zip_linux 网络_tcp
09-15
在Linux平台上进行网络编程，TCP（Transmission Control Protocol）是一种常用且重要的传输层协议，它提供了面向连接、可靠的字节流服务。本教程将探讨如何利用Linux系统编程接口，实现一个简单的TCP服务器，允许...
Linux网络编程，包括tcp/upd，select/poll/epoll/pdf
04-14
linux网络编程 pdf # Linux网络编程基础 Linux网络编程是指在Linux操作系统上开发网络应用程序的过程。它主要涉及到TCP/UDP协议以及select/poll/epoll等多路复用技术。 TCP/UDP协议是网络通信的基础，其中TCP协议...
linux下网络编程TCP客户端和服务器端数据传输代码
01-14
在Linux环境下进行网络编程，TCP协议是最常用的传输层协议之一，因为它提供了面向连接、可靠的数据传输服务。本篇文章将深入探讨如何使用C语言在Linux下编写TCP客户端和服务器端的数据传输代码。 首先，TCP服务器端...
linux网络编程,linux网络编程 pdf,C,C++
09-10
在Linux环境中，开发者通常会使用套接字API（Socket API）来进行网络编程。该API提供了丰富的函数，如socket()用于创建套接字，bind()用于绑定本地地址，listen()和accept()用于TCP的服务器端监听和接受连接，...
TCP.zip_DEMO_LINUX TCP _linux 网络通信_linux 网络_linux 网络编程
09-22
本教程主要探讨如何在Linux环境下利用TCP进行网络编程，通过提供的"TCP.zip_DEMO_LINUX TCP _linux 网络通信_linux 网络_linux 网络编程"压缩包中的示例代码，你可以学习到以下关键知识点： 1. **套接字接口**：在...
使用 Squid 搭建 Http 代理服务器隐藏 IP
最新发布
玖涯博客
08-03 375
在一些情况下，需要变更自己的访问 IP，可以通过Squid搭建代理服务器实现。本文使用的是CentOS 7.6系统。
利用 IP 地址进行社交工程攻击？
m0_73609283的博客
08-02 276
在用户信任的基础上，诱导其执行某些操作，如提供密码、银行账号、点击恶意链接等，从而达到窃取信息或控制用户设备的目的。通过电子邮件、电话、即时通讯等方式与目标用户建立联系，运用专业的语言、熟悉的术语和看似合法的理由获取用户的信任。用户应注意保护个人信息，避免在不可信的平台上随意透露 IP 地址等敏感信息，企业也应加强对用户数据的保护和管理。对于涉及重要信息和操作的请求，用户应通过官方渠道进行核实和验证，不要仅仅依赖于来自身份不明的来源的信息。根据收集到的信息，设计一个看似合理且与目标用户相关的攻击场景。
C#Tcp中分包粘包问题以及UDP简单的介绍
weixin_64532720的博客
08-03 782
TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。由于TCP是基于字节流的，它不会保留消息边界，这可能导致所谓的“粘包”或“分包”问题。
53 SSLVPN IP 接入
qq_56248592的博客
08-03 148
清除通过IP接入的SSL VPN用户的报文统计信息 reset sslvpn ip-tunnel statistics [ context context-name [ session session-id ] ]显示通过IP接入的SSL VPN用户的报文统计信息 display sslvpn ip-tunnel statistics [ context context-name ] [ user user-name ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值