TCP套接字相关知识

最新推荐文章于 2024-09-13 18:41:04 发布
最新推荐文章于 2024-09-13 18:41:04 发布
阅读量557 收藏 1
点赞数 1
分类专栏： Linux网络编程 文章标签： tcp/ip 网络 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57249790/article/details/131503849
版权

TCP特有的相关接口

listen接口

#include <sys/types.h>
#include <sys/socket.h>

int listen(int sockfd,int backlog);


返回值

成功 0被返回
失败 -1被返回

accept接口

#include <sys/types.h>
#include <sys/socket.h>

int accept(int sockfd,struct sockaddr *addr,socklen_t *addrlen);

 返回值

返回文件描述符


connect接口

#include <sys/types.h>
#include <sys/socket.h>

int connect(int sockfd,const struct sockaddr *addr,socklen_t addrlen);

 返回值 

成功 0被返回。
失败 -1被返回。
并且在connect的时候返回成功自定bind。

普通版本代码

服务端

套接字的创建

// 1. 创建socket文件套接字对象
_listensock = socket(AF_INET, SOCK_STREAM, 0);
if (_listensock < 0)
{
    logMessage(FATAL, "create socket error");
    exit(SOCKET_ERR);
}
logMessage(NORMAL, "create socket success");

 bind连接

// 2.bind绑定自己的网络信息
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(_listensock, (struct sockaddr *)&local, sizeof(local)) < 0)
{
    logMessage(FATAL, "bind socket error");
    exit(BIND_ERR);
}
logMessage(NORMAL, "bind socket success");

 listen监听接口

TCP是面向连接的所以需要将套接字设置为监听状态


// 3. 设置socket 为监听状态
if (listen(_listensock, gbacklog) < 0) // TODO
{
    logMessage(FATAL, "listen socket error");
    exit(LISTEN_ERR);
}
logMessage(NORMAL, "listen socket success");

客户端在何时连接？ 

 客户端连接服务端的时候，服务端需要就可以accept到客户端发来的信息。

accept接口

// 4. server 获取新链接
// sock 和客户端进行通信的fd
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
int sock = accept(_listensock, (struct sockaddr *)&peer, &len);

if (sock < 0)
{
    logMessage(ERROR, "accept error, next");
    cout << "sock: " << sock << endl;

    continue;
}
logMessage(NORMAL, "accept a new link success,get new sock: %d", sock);

serviceIO 服务端的服务

先读后写

void serviceIO(int sock)
{
    char buffer[1024];
    while (true)
    {
        size_t n = read(sock, buffer, sizeof(buffer) - 1);
        if (n > 0)
        {
            // 目前我们把读到的数据当成字符串，截至目前
            buffer[n] = 0;
            std::cout << "recv message: " << buffer << std::endl;

            std::string outbuffer = buffer;
            outbuffer += " server[echo]";

            write(sock, outbuffer.c_str(), outbuffer.size()); // 多路转接
        }

        else if (n == 0)
        {
            // 代表client退出
            logMessage(NORMAL, "client quit , me too!");
            break;
        }
    }
    close(sock);
}

客户端代码

创建套接字


// 1. 创建socket
_sock = socket(AF_INET, SOCK_STREAM, 0);
if (_sock < 0)
{
    cerr << "socket create error" << endl;
}

// 2. tcp的客户端要不要bind？ 要的 要不要显示的bind？
// 不要！ 这里尤其是client port要让OS自定随机自定！
// 3. 要不要listen？不要！只有服务端需要！
// 4. 要不要accept？不要！只有服务端需要！
// 5. 要什么呢？？要发起链接！

 链接  发送数据


void start()
{
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(_serverport);
    server.sin_addr.s_addr = inet_addr(_serverip.c_str());

    int con = connect(_sock, (struct sockaddr *)&server, sizeof(server));
    if (con != 0)
    {
        cerr << "socket connect error" << endl;
    }
    else
    {
        string msg;
        while (true)
        {
            cout << "Enter# ";
            getline(cin, msg);
            write(_sock, msg.c_str(), msg.size());

            char buffer[NUM];
            int n = read(_sock, buffer, sizeof(buffer) - 1);

            if (n > 0)
            {

                // 目前我们把读到的数据当字符串，截至目前
                buffer[n] = 0;
                cout << "Server回显# " << buffer << endl;
                buffer[0] = 0;
            }
            else
            {
                break;
            }
        }
    }
}

普通版本完整代码

makefile

cc=g++

.PHONY:all
all:tcpclient tcpserver

tcpclient:tcpClient.cc
	$(cc) -o $@ $^ -std=c++11

tcpserver:tcpServer.cc
	$(cc) -o $@ $^ -lpthread -std=c++11

.PHONY:clean
clean:
	rm -f tcpclient tcpserver

tcpserver.hpp


#pragma once
#include <iostream>
#include <stdlib.h>
#include <string>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>
#include <pthread.h>

#include "log.hpp"
#include "Task.hpp"
#include "ThreadPool.hpp"
using namespace std;

namespace server
{

    enum
    {
        USAGE_ERR = 1,
        SOCKET_ERR,
        BIND_ERR,
        LISTEN_ERR
    };

    static const uint16_t gport = 8080;
    static const int gbacklog = 5;

    class TcpServer;

    class ThreadData
    {
    public:
        ThreadData(TcpServer *self, int sock)
            : _self(self), _sock(sock)
        {
        }
        ~ThreadData()
        {
        }
        TcpServer *_self;
        int _sock;
    };

    class TcpServer
    {
    public:
        TcpServer(const uint16_t &port = gport) : _listensock(-1), _port(port)
        {
        }
        void initServer()
        {

            // 1. 创建socket文件套接字对象
            _listensock = socket(AF_INET, SOCK_STREAM, 0);
            if (_listensock < 0)
            {
                logMessage(FATAL, "create socket error");
                exit(SOCKET_ERR);
            }
            logMessage(NORMAL, "create socket success");

            // 2.bind绑定自己的网络信息
            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(_listensock, (struct sockaddr *)&local, sizeof(local)) < 0)
            {
                logMessage(FATAL, "bind socket error");
                exit(BIND_ERR);
            }
            logMessage(NORMAL, "bind socket success");

            // 3. 设置socket 为监听状态
            if (listen(_listensock, gbacklog) < 0) // TODO
            {
                logMessage(FATAL, "listen socket error");
                exit(LISTEN_ERR);
            }
            logMessage(NORMAL, "listen socket success");
        }

        void start()
        {
            for (;;)
            {
                // 4. server 获取新链接
                // sock 和客户端进行通信的fd
                struct sockaddr_in peer;
                socklen_t len = sizeof(peer);
                int sock = accept(_listensock, (struct sockaddr *)&peer, &len);

                if (sock < 0)
                {
                    logMessage(ERROR, "accept error, next");
                    cout << "sock: " << sock << endl;

                    continue;
                }
                // logMessage(NORMAL, "accept a new link success,get new sock: %d", sock);
                logMessage(NORMAL, "accept a new link success");
                cout << "sock: " << sock << endl;

                    // 5. 这里就是一个sock，未来通信我们就用这个sock，面向字节流的，后续全部都是文件操作！

                    // version 1
                    serviceIO(sock);
                close(sock); // 对一个就已经使用完毕的sock，我们要关闭这个sock
                // 要不然会导致。
                // version 多进程版 多线程版 线程池版

                
            }
        }

       

        void serviceIO(int sock)
        {
            char buffer[1024];
            while (true)
            {
                ssize_t n = read(sock, buffer, sizeof(buffer) - 1);
                if (n > 0)
                {
                    // 目前我们把读的数据当成字符串，截止目前
                    buffer[n] = 0;
                    cout << "recv message: " << buffer << endl;

                    string outbuffer = buffer;
                    outbuffer += "server[echo]";

                    write(sock, outbuffer.c_str(), outbuffer.size());
                }
                else if (n == 0)
                {
                    // 代表客户端退出
                    logMessage(NORMAL, "client quit,me too!");
                    break;
                }
            }
        }
        ~TcpServer()
        {
        }

    private:
        int _listensock; // 不是用来进行数据通信的，它是用来监听链接到来，获取新链接的！
        uint16_t _port;
    };
}

tcpserver.cc

#include "tcpServer.hpp"
#include "daemon.hpp"
#include <memory>

using namespace server;
using namespace std;

static void Usage(string proc)
{
    cout << "\nUsage:\n\t" << proc << " local_port\n\n";
}

// tcp服务器，启动上和udp server一模一样
// ./tcpServer local_port
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    uint16_t port=atoi(argv[1]); // 字符串转整型

    unique_ptr<TcpServer> tsvr(new TcpServer(port));

    tsvr->initServer();
    // daemonSelf();
    tsvr->start();



    return 0;
}

tcpclient.hpp

#pragma once

#include <iostream>
#include <string>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

using namespace std;

#define NUM 1024

class TcpClient
{
public:
    TcpClient(const string &serverip, const uint16_t &serverport)
        : _sock(-1), _serverip(serverip), _serverport(serverport)
    {
    }
    void initClient()
    {
        // 1. 创建socket
        _sock = socket(AF_INET, SOCK_STREAM, 0);
        if (_sock < 0)
        {
            cerr << "socket create error" << endl;
        }
        // 2. tcp的客户端要不要bind？ 要的 要不要显示的bind？
        // 不要！ 这里尤其是client port要让OS自定随机自定！
        // 3. 要不要listen？不要！只有服务端需要！
        // 4. 要不要accept？不要！只有服务端需要！
        // 5. 要什么呢？？要发起链接！
    }

    void start()
    {
        struct sockaddr_in server;
        memset(&server, 0, sizeof(server));
        server.sin_family = AF_INET;
        server.sin_port = htons(_serverport);
        server.sin_addr.s_addr = inet_addr(_serverip.c_str());


        int con = connect(_sock, (struct sockaddr *)&server, sizeof(server));
        if (con != 0)
        {
            cerr << "socket connect error" << endl;
        }
        else
        {
            string msg;
            while (true)
            {
                cout << "Enter# ";
                getline(cin, msg);
                write(_sock, msg.c_str(), msg.size());

                char buffer[NUM];
                int n = read(_sock, buffer, sizeof(buffer) - 1);

                if (n > 0)
                {

                    // 目前我们把读到的数据当字符串，截至目前
                    buffer[n] = 0;
                    cout << "Server回显# " << buffer << endl;
                    buffer[0] = 0;
                }
                else
                {
                    break;
                }
            }
        }
    }
    ~TcpClient()
    {
        if (_sock >= 0)
        {
            close(_sock);
        }
    }

private:
    int _sock;
    string _serverip;
    uint16_t _serverport;
};

tcpclient.cc

#include "tcpClient.hpp"
#include <memory>

using namespace std;

static void Usage(string proc)
{
    cout << "\nUsage:\n\t" << proc << " serverip serverport\n\n";
}

// ./tcpclient serverip serverport
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }

    string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);

    unique_ptr<TcpClient> tcli(new TcpClient(serverip, serverport));

    tcli->initClient();
    tcli->start();

    return 0;
}


// log.hpp

#pragma once

#include <iostream>
#include <string>
#include <stdarg.h>
#include <time.h>
#include <unistd.h>

using namespace std;

void logMessage(int level, const char *message)
{
    cout << message << endl;
}

多进程版本

版本一

孙子进程进行提供服务

// 多进程版本1
// version 2
pid_t id = fork();

if (id == 0) // child
{
    close(_listensock); // 子进程中不需要监听因此关闭监听的文件描述符
    if (fork() > 0)
        exit(0);

    serviceIO(sock);
    close(sock);
    exit(0);
}

// father
pid_t ret = waitpid(id, nullptr, 0);

if (ret > 0)
{
    cout << "waitsuccess: " << ret << endl;
}

版本二

通过屏蔽信号SIGCHLD来防止僵尸进程

// 多进程版本2
signal(SIGCHLD, SIG_IGN);

pid_t id = fork();
if (id == 0) // child
{
    close(_listensock);
    // if(fork()>0) exit(0);
    serviceIO(sock);
    close(sock);
    exit(0);
}
close(sock);

多线程版本

static void *threadRoutine(void *args)
{
    pthread_detach(pthread_self()); // 线程分离 互不干扰
    ThreadData *td = static_cast<ThreadData *>(args);

    td->_self->serviceIO(td->_sock);
    delete td;
    close(td->_sock);
    return nullptr;
}

pthread_t tid;
ThreadData *td = new ThreadData(this, sock);
pthread_create(&tid, nullptr, threadRoutine, td);

线程池版本

线程池初始化

ThreadPool<Task>::getInstance()->run();

线程池

ThreadPool<Task>::getInstance()->push(Task(sock, serviceIO));
####################################
Task.hpp
####################################

#pragma once

#include <iostream>
#include <functional>
#include <string>
#include <cstdio>

void serviceIO(int sock)
{
    char buffer[1024];
    while (true)
    {
        size_t n = read(sock, buffer, sizeof(buffer) - 1);
        if (n > 0)
        {
            // 目前我们把读到的数据当成字符串，截至目前
            buffer[n] = 0;
            std::cout << "recv message: " << buffer << std::endl;

            std::string outbuffer = buffer;
            outbuffer += " server[echo]";

            write(sock, outbuffer.c_str(), outbuffer.size()); // 多路转接
        }

        else if (n == 0)
        {
            // 代表client退出
            logMessage(NORMAL, "client quit , me too!");
            break;
        }
    }
    close(sock);
}

// 计算数据的类
class Task
{
    using func_t = std::function<void(int)>;

public:
    Task()
    {
    }

    Task(int sock, func_t func)
        : _sock(sock), _callback(func)
    {
    }

    // 该函数是消费任务的打印信息
    void operator()()
    {
        _callback(_sock);
    }

private:
    int _sock;
    func_t _callback;
};

####################################
ThreadPool.hpp
####################################

#pragma once

#include "Thread.hpp"
#include "LockGuard.hpp"
#include "log.hpp"
#include <vector>
#include <queue>
#include <pthread.h>
#include <unistd.h>
#include <mutex>

using namespace ThreadNs;

const int gnum = 10;

template <class T>
class ThreadPool;

template <class T>
class ThreadData
{
public:
    ThreadPool<T> *threadpool;
    std::string name;

public:
    ThreadData(ThreadPool<T> *tp, const std::string &n)
        : threadpool(tp), name(n)
    {
    }
};

template <class T>
class ThreadPool
{
private:
    static void *handlerTask(void *args)
    {
        ThreadData<T> *td = (ThreadData<T> *)args;
        while (true)
        {
            T t;
            {
                LockGuard lockguard(td->threadpool->mutex());

                while (td->threadpool->isQueueEmpty())
                {
                    td->threadpool->threadWait();
                }

                // pop的本质，是将任务从公共的队列当中，拿到当前线程自己独立的栈中
                t = td->threadpool->pop();
            }
            t();
        }
        delete td;
        return nullptr;
    }
    // 单例模式：构造函数设置为私有
    ThreadPool(const int &num = gnum) : _num(num)
    {
        pthread_mutex_init(&_mutex, nullptr);
        pthread_cond_init(&_cond, nullptr);

        for (int i = 0; i < _num; i++)
        {
            _threads.push_back(new Thread());
        }
    }
    void operator=(const ThreadPool &) = delete;
    ThreadPool(const ThreadPool &) = delete;

    // 为了解决static handlerTask
public:
    void lockQueue()
    {
        pthread_mutex_lock(&_mutex);
    }

    void unlockQueue()
    {
        pthread_mutex_unlock(&_mutex);
    }
    bool isQueueEmpty()
    {
        return _task_queue.empty();
    }
    void threadWait()
    {
        pthread_cond_wait(&_cond, &_mutex);
    }
    T pop()
    {
        T t = _task_queue.front();
        _task_queue.pop();
        return t;
    }
    pthread_mutex_t *mutex()
    {
        return &_mutex;
    }

public:
    void run()
    {
        for (const auto &t : _threads)
        {
            ThreadData<T> *td = new ThreadData<T>(this, t->threadname());

            t->start(handlerTask, td);
            std::cout << t->threadname() << " start ..." << std::endl;
            // logMessage(DEBUG, "%s start ...", t->threadname().c_str());
        }
    }

    void push(const T &in)
    {
        LockGuard lockguard(&_mutex);
        _task_queue.push(in);
        pthread_cond_signal(&_cond);
    }

    ~ThreadPool()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond);

        for (const auto &t : _threads)
            delete t;
    }

    static ThreadPool<T> *getInstance()
    {
        // 最外边这个if的作用是：
        // 如果tp已经被创建，那么就不用创建了，因为是单例模型
        if (nullptr == tp)
        {
            _singlock.lock();
            if (nullptr == tp)
            {
                tp = new ThreadPool<T>();
            }
            _singlock.unlock();
        }

        return tp;
    }

private:
    int _num;

    std::vector<Thread *> _threads; // 线程集合
    std::queue<T> _task_queue;      // 任务队列

    pthread_mutex_t _mutex;
    pthread_cond_t _cond;

    static ThreadPool<T> *tp;
    static std::mutex _singlock;
};

template <class T>
ThreadPool<T> *ThreadPool<T>::tp = nullptr;

template <class T>
std::mutex ThreadPool<T>::_singlock;

日志


#pragma once

#include <iostream>
#include <string>
#include <stdarg.h>
#include <time.h>
#include <unistd.h>

using namespace std;

#define LOG_NORMAL "log.txt"
#define LOG_ERR "log.error"

#define DEBUG 0
#define NORMAL 1
#define WRNING 2
#define ERROR 3
#define FATAL 4

// 根据不同的日志等级来返回不同的日志信息
const char *to_levelstr(int level)
{
    switch (level)
    {
    case DEBUG:
        return "DEBUG";
    case NORMAL:
        return "NORMAL";
    case WRNING:
        return "WRNING";
    case ERROR:
        return "ERROR";
    case FATAL:
        return "FATAL";
    default:
        return nullptr;
    }
}
// [日志等级] [时间戳/时间] [pid] [message]
// [WARNING] [2023-6-29 8:25:08] [123] [创建socket失败]

// va_list start;

// start 指针

// va_start(start); -- 把start指向第一个

// va_arg(start,float); 让这个指针向后移动指定类型的大小

// va_end(start); 让start这个指针设为NULL
// while (*p)
// {
//     switch (*p)
//     {
//     case '%':
//         p++;
//         if (*p == 'f')
//             arg = va_arg(start, float);
//         // ...
//     }
// }
// va_end(start);

// void logMessage(DEBUG, "hello %f, %d, %c",3.14,10,'C');
void logMessage(int level, const char *format, ...)
{
#define NUM 1024
    char logprefix[NUM];
    // logprefix
    // [日志等级] [时间戳/时间] [pid] 
    snprintf(logprefix, sizeof(logprefix), "[%s][%ld][pid: %d]",
             to_levelstr(level), (long int)time(nullptr), getpid());

    char logcontent[NUM];
    va_list arg;
    va_start(arg, format);
    // [message]
    vsnprintf(logcontent, sizeof(logcontent), format, arg);

    cout << logprefix << logcontent << endl;

    FILE *log = fopen(LOG_NORMAL, "a");
    FILE *err = fopen(LOG_ERR, "a");

    if (log != nullptr && err != nullptr)
    {
        FILE *curr = nullptr;
        if (level == DEBUG || level == NORMAL || level == WRNING)
            curr = log;
        if (level == ERROR || level == FATAL)
            curr = err;
        if (curr)
            fprintf(curr, "%s%s\n", logprefix, logcontent);

        fclose(log);
        fclose(err);
    }
}

守护进程

解析

不受用户登录注销的进程。

setsid 接口

#include <unistd.h>

pid_t setsid(void);

TCP套接字编程
weixin_43786290的博客
12-25 852
一、sokcet 1、socket（套接字）编程是C/S模型网络通信中最常用的编程技术。socket是操作系统提供用于进程通信的API接口（API接口即应用程序接口，为一个软件组件或是一个Web服务与外界进行交互的接口）。 二、TCP通信模型 1、TCP协议位于传输层，提供报文的可靠传输。TCP协议通过超时重传和确认两大机制保证了数据传输的可靠性。 2、TCP通信过程 （1）建立连接：服务器需要先启动。 1）服务器启动后绑定固定端口进行监听，等待客户端连接： ServerSocket server=new
TCP套接字
Ftworld21的专栏
09-18 225
TCP套接字类主要对底层的读写，压缩，加密等进行了封装，提供了一个比较通过的接口，通过这个类就可以实现数据的接收与发送。 //封装了一个缓冲区，用于TCP套接口接收到发送的缓冲区 template <typename T> class Buffer { public: ... private: ... T buffer; }; typedef Buffer<std::vector<unsigned char> > Buffer_t; clas...
Tcp套接字
最新发布
2302_78814792的博客
09-13 766
TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。TCP套接字（Socket）是实现TCP协议进行网络通信的关键机制。TCP套接字广泛应用于各种需要可靠传输数据的网络应用程序中，如Web服务器（HTTP）、文件传输（FTP）、远程登录（SSH）等。：当客户端断开连接后，与客户端相连接的Socket对象也应当被关闭，否则其将会占用文件描述符表，导致资源浪费。在编程中，TCP套接字的实现依赖于操作系统提供的套接字API。
TCP的套接字
weixin_43304464的博客
05-05 3184
TCP的套接字 = IP + 端口号 套接字有三种：1.流式套接字（SOCK_STREAM）；2：数据报套接字（SOCK_DGRAM）；3.原始套接字（SOCK_RAW） 基于TCP的socket编程是采用的流式套接字。 分为以下步骤： 1：加载套接字库，创建套接字(WSAStartup()/socket())； 2：绑定套接字到一个IP地址和一个端口...
TCP网络套接字
m0_74910646的博客
08-09 1438
这里还有一个小细节，子进程会继承父进程的文件描述符表，我们知道每一个客户端会对应一个sockfd，而文件描述符表本质就是一个数组，也是有数量大小的，当客户端的数量比较多了的话文件描述符表可能就会被占满，其次父进程不关心业务执行什么，也就是父进程不关心sockfd，所以每当创建一个子进程建议父进程将sockfd关掉，也建议子进程将listenfd也关掉方式误操作，这样不论有多少个客户端，其对应的文件描述符永远是4。这样，当套接字进行通信时，就可以使用这个指定的地址作为通信的源地址。
基于Python进行TCP套接字编程的基础知识 实验报告
01-08
进一步理解和掌握基于Python进行TCP套接字编程的知识，理解SMTP报文格式，能基于Python编写一个简单的SMTP客户端程序。 2实验条件 装有python环境的电脑两台 局域网环境 已经正常运行的邮件服务器 3实验报告内容及...
tcp套接字例子windos
04-10
下面我们将深入探讨TCP套接字在Windows环境中的应用，并基于`select`函数的使用来理解相关知识点。 1. **TCP套接字基础**： TCP是一种面向连接的、可靠的传输层协议，它保证了数据包按顺序无丢失地到达目的地。在...
3_tcp.rar_TCP 套接字_TCP服务_linux聊天TCP
09-24
"3_tcp.rar"这个压缩包文件包含了关于TCP套接字、TCP服务以及在Linux环境下实现聊天应用的相关资料，让我们深入探讨一下这些知识点。 首先，TCP套接字是实现TCP通信的基础。套接字（Socket）可以看作是两台计算机...
Python网络编程之TCP套接字简单用法示例
09-20
Python网络编程中的TCP套接字是网络通信的基础，它提供了可靠的数据传输服务，适用于需要保持连接状态的应用场景，如文件传输、远程登录等。在Python中，我们可以使用内置的`socket`模块来实现TCP套接字编程。下面将...
MFC的TCP套接字服务端程序代码
05-12
总的来说，"MFC的TCP套接字服务端程序代码"涉及了C++、MFC框架、TCP网络通信和多线程编程等多个方面的知识。通过分析提供的源代码和文档，开发者可以深入理解MFC如何简化网络编程，以及如何构建一个健壮的TCP服务器...
网络编程套接字（ TCP ）
bit_zyx的博客
03-22 3722
目录 1、实现一个TCP网络程序（单进程版） 1.1、服务端serverTcp.cc文件 服务端创建套接字 服务端绑定 服务端监听 服务端获取连接 服务端提供服务 服务端main函数命令行参数 服务端serverTcp.cc总代码
TCP套接字通信
心飞扬
07-26 2639
TCP套接字通信网络中进程之间如何通信？我们知道在本地进程间通信有很多种方式:比如管道、消息队列、共享内存、同步与互斥等，这些方法都要求通信的两个进程位于同一个主机那么网络之间该如何通信呢？在本地可以用进程PID来唯一的标识一个进程，但是在网络中是不行的，通过以前所学TCP/IP等知识，我们清楚网络层的“ip地址”可以唯一标识网络中的主机，而传输层的“端口号”又可以唯一标识主机中的应用程序。这样，我
TCP实现之：套接字
qq_17045267的博客
06-16 2016
TCP实现之：套接字 套接字的数据结构按照域的不同可以分为三种：用户态套接字、socket和sock，其中socket结构体是内核中的与用户态相似的套接字数据结构，可以理解为它是为用户态提供的一种接口，而sock结构体比较复杂，它是内核用来进行数据传输的数据结构，可以理解为它是套接字的实现。这三种套接字可谓息息相关。 struct socket 这里的socket又被称为BSD socket（伯克利套接字），它对应着网络模型中的表示层，其定义比较简单，只有7个字段，如下： struct socket {
【网络】套接字 -- TCP
qq_59456417的博客
03-02 2269
TCP套接字服务器端和TCP客户端的简单实现。
网络编程——Tcp套接字
学代码的咸鱼的博客
07-03 530
TCP套接字的简单实现！
TCP套接字总结
yehongji1024的博客
07-23 292
TCP基本套接字函数 简介 介绍完TCP连接的基本流程后，本文将着重介绍TCP连接时所使用的套接字函数。 函数 socket函数 #include <sys/socket.h> int socket(int family, int type, int protocol); //family:所使用协议族；AF_INET为IPv4协议；AF_INET6为IPv6协议。 //type:套接字类型；SOCK_STREAM为字节流套接字。 //protocol:协议类型常值，如IPPROTO_TCP,或
TCP套接字编程入门教程：服务器端详解
这篇文档提供了一套完整且易于理解的TCP套接字编程教程，对于想要学习网络编程，尤其是服务器端开发的初学者来说，是极好的学习资料。理解这些核心概念后，可以进一步探索UDP套接字的异步特性，以及如何在实际项目中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

袁百万

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

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

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

打赏作者

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

抵扣说明：

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

余额充值