C++ 网络编程：一个可复用的套接字管理类和一个简单用例

最新推荐文章于 2024-05-23 22:49:45 发布
最新推荐文章于 2024-05-23 22:49:45 发布
阅读量1k 收藏 1
点赞数
分类专栏： 网络编程 文章标签： socket select C++ Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wylewylie/article/details/50906523
版权

C++网络编程公共类

本文章使用C++提供的几个基本网络编程相关调用，进行封装，提供必要的出错处理等功能，用select实现对端口数据的接收。

目标：实现一个通用的套接字管理类
  • create
  • connect
  • bind
  • listen
  • accept
  • recv
  • close

头文件public.h

#ifndef __SOCKET_MGR_H__
#define __SOCKET_MGR_H__
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/un.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <arpa/inet.h>
#include <ifaddrs.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>



#define MAXSOCKFD 1024
#define MAX_MSG_BUF_HEAD 8
#define MAX_MSG_BUF 4000       //1024
#define BUFFLEN 1024
#define MAXCLIENT 50
#define RETRY_SEND 5

#define QUERY_SLAVE_TIME_INTERVAL 2*60*1000*1000  /*2 minutes*/

typedef struct fsocket_info fsock_info;

class CSocketMgr
{
public:
    CSocketMgr();
    ~CSocketMgr();


    /*停止本地服务*/
    int stop_sock_mgr();
    int sock_create(int, int, int);
    int sock_connect(int, struct sockaddr *, int);
    int sock_bind(int, struct sockaddr *, int);
    int sock_listen(int, int);
    int sock_send(int, const char *, unsigned int ,int);
    int sock_recv(int, char *, unsigned int *, int);
    void sock_close(int *fd);

    /*循环接收命令接收线程*/
    static void* s_accept_routine(void* context);
    static void *s_recv_routine(void *context);
    int send_request(char *, int);
    int accept_routine(int, fsock_info *, int);
    int recv_routine(fsock_info *);
    void *set_fd_to_arry(int, struct sockaddr_in, fsock_info *, int);

    int recv_msg(fsock_info *);

    int sync_send_and_recv(char const *ip, int port, const char *, char *, unsigned int send_len, unsigned int *recv_len);
    int sync_send(char const *ip, int port, const char * buf, int len);
private:
    int ser_sock_fd;
    pthread_t accept_thread;
    pthread_t recv_thread;
    bool _running;
    int _socket;//本地socket
    pthread_t client_thread[MAXCLIENT];
    CXmlBuilder _node_info;
    MutexLock _mutex;
    char *_pBuf;
    /*可以组合公共网络类*/
};


typedef struct fsocket_info
{
    bool sock_fd_use_flag;
    time_t accept_time;
    int sock_fd;
    struct sockaddr_in client_addr;
} fsock_info;

typedef struct ObjectFd
{
    int listen_type;
    fsock_info *watch_sock;
    class CSocketMgr _sock_mgr;
} ObjectFd;

typedef struct Client_Info
{
    char ip[16];
    int port;
    class CSocketMgr *client_this;
} Client_Info;

#endif
//定义结束
具体实现public.cpp
#include "public.h"

pthread_mutex_t my_mutex;

#define min(a, b) ((a) > (b) ? (b) :(a))
#define RECV_BUF 4*1024*1024


CSocketMgr::CSocketMgr()//公共网络模块的构造
: _pBuf(NULL)
{
    _pBuf = (char *)calloc(1, RECV_BUF);
    if (_pBuf == NULL)
    {
        printf("there isn't enough memory to be allocatede\n");
    }
}

CSocketMgr::~CSocketMgr()
{
    if (_pBuf != NULL)
    {
        free(_pBuf);
    }
}

int CSocketMgr::sock_create(int af, int type, int protocol)//创建套接字
{
    return socket(af, type, protocol);
}

int CSocketMgr::sock_connect(int cli_sock_fd, struct sockaddr *serv_addr, int len)//连接套接字
{
    int ret = 0;
    int retry_count = 0;

RETRY_COUNT:    
    do 
    {
        ret = connect(cli_sock_fd, serv_addr, len);
    } while (ret < 0 && errno == EINTR);
    if (ret == -1)
    {
        printf("sock connect failed:%s, errno=%d\n", strerror(errno), errno);
        retry_count++;
        if (retry_count < 5)
        {
            goto RETRY_COUNT;
        }
        ret = -1;
    }

    return ret;
}

int CSocketMgr::sock_bind(int ser_sock_fd, struct sockaddr *serv_addr, int len)//绑定套接字
{
    int ret = -1;
    /*an error maybe happended when bind, as sometimes when device reboot, the port which will be used not be accured, but bind failed*/
    for (int i = 0; i < 2*60; i++)
    {
        ret = bind(ser_sock_fd, serv_addr, len);
        if (ret == 0)
        {
            break;
        }
        else
        {
            printf("bind error: %s\n", strerror(errno));
            usleep(1000000);
        }
    }
    return ret;
}

int CSocketMgr::sock_listen(int ser_sock_fd, int maxsockfd)//监听套接字
{
    return listen(ser_sock_fd, maxsockfd);
}

void *CSocketMgr::s_recv_routine(void * context)
{
    ObjectFd *object_fd = (ObjectFd *)context;
    CSocketMgr *_this = &object_fd->_sock_mgr;
    fsock_info *sock_info = object_fd->watch_sock;

    if (_this != NULL)
    {
        _this->recv_routine(sock_info);
    }
    return NULL;
}


int CSocketMgr::recv_msg(fsock_info *sock_info)//接受消息
{
    if (_pBuf != NULL)
    {
        memset(_pBuf, 0, RECV_BUF);
    }
    int len = RECV_BUF;
    char *msg_buf = _pBuf;

    int ret = 0;
    int bytes_read;
    int bytes_left = len; 
    int i = 0;   
    int msg_size = 0;

    struct timeval tv;
    tv.tv_sec = 2;
    tv.tv_usec = 0;
    setsockopt(sock_info->sock_fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));

    do
    {
        while((bytes_read = recv(sock_info->sock_fd, msg_buf, bytes_left, 0)) == -1 && errno == EINTR);
        if(bytes_read < 0)
        {
            printf("recv_msg %s %d\n", strerror(errno), errno);
            ret = -1;
            goto finial_exit;
        }
        if ((bytes_read >= 8) && (i == 0))
        {
            i++;
            memcpy(&msg_size, msg_buf + 4, 4);
        }

        bytes_left -= bytes_read;
        msg_buf += bytes_read;
    } while (len - bytes_left < msg_size);

    //printf("recv_msg  = %d\n", msg_size);
    if ((ret == 0) && (msg_size >= 8))
    {
        msg_porc(sock_info, _pBuf);//根据套接字的内容进行相应操作，根据具体项目有所不同
    }

finial_exit:
    //printf("recv_msg len %d\n", len - bytes_left);
    return len - bytes_left;

}

int CSocketMgr::recv_routine(fsock_info *sock_info)//select实现recv
{
    int i;
    int ret = -1;
    int maxfd = -1;
    fd_set readfds;
    struct timeval tvl;

    tvl.tv_sec = 2;
    tvl.tv_usec = 0;

    printf("enter the recv routine\n");
    while (1/*此处需要用变量*/)
    {
        i = 0;
        FD_ZERO(&readfds);
        while(i < MAXSOCKFD)
        {
            pthread_mutex_lock(&my_mutex);
            if(sock_info[i].sock_fd > 0)
            {
                FD_SET(sock_info[i].sock_fd, &readfds);
                if (maxfd < sock_info[i].sock_fd)
                {
                    maxfd = sock_info[i].sock_fd;
                }
            }
            pthread_mutex_unlock(&my_mutex);
            i++;
        }

        ret = select(maxfd + 1, &readfds, NULL, NULL, &tvl);
        if (ret > 0)    
        {
            i = 0;
            while (i < MAXSOCKFD)
            {
                pthread_mutex_lock(&my_mutex);
                if (sock_info[i].sock_fd > 0)
                {
                    if (FD_ISSET(sock_info[i].sock_fd, &readfds))
                    {
                        ret = recv_msg(&sock_info[i]);
                    }
                }
                pthread_mutex_unlock(&my_mutex);
                i++;
            }
        }

        usleep(10000);

    }
    return 0;
}

int CSocketMgr::accept_routine(int ser_sock_fd, fsock_info *local_watch_sock, int is_need_heart)/*accept实现，将accept的套接字填入结构体数组，供select监测*/
{
    int accept_sock_fd = -1;
    struct sockaddr_in cli_addr;
    int len = sizeof(cli_addr);

    while (1/*此处需要用变量*/)
       {
        accept_sock_fd = accept(ser_sock_fd, (struct sockaddr*)&cli_addr, (socklen_t *)&len);
        if (accept_sock_fd != -1)
        {
            set_fd_to_arry(accept_sock_fd, cli_addr, local_watch_sock, is_need_heart);
        }
        usleep(20000);
    }
    close(ser_sock_fd);

    return 0;
}

void *CSocketMgr::set_fd_to_arry(int accept_sock_fd,struct sockaddr_in cli_addr, fsock_info *watch_sock, int is_need_heart)//功能同上
{
    int i = 0;

    pthread_mutex_lock(&my_mutex);
    for (i = 0; i < MAXSOCKFD; i++)
    {
        if (watch_sock[i].sock_fd > 0)
        {
            continue;
        }

        watch_sock[i].sock_fd = accept_sock_fd;
        memcpy(&(watch_sock[i].client_addr), &cli_addr, sizeof(cli_addr));
        if (is_need_heart)
        {
            time_t timep;
            time(&timep);
            watch_sock[i].accept_time = timep;
        }
        break;
    }
    pthread_mutex_unlock(&my_mutex);
    if (i >= MAXSOCKFD)
    {
        printf("listen queue is full!");
    }
    return NULL;
}

int CSocketMgr::sock_send(int sock_fd, const char *buf, unsigned int len, int flag)
{
    ssize_t ret;
    size_t bytes_sent = 0;
    int retrycount = 0;

    _mutex.lock();    
    do
    {
        if (sock_fd <= 0)
        {
            printf("sock_fd error!\n");
            _mutex.unlock();
            return -1;
        }
        ret = send(sock_fd, (char*)buf + bytes_sent, min(len - bytes_sent, 0x2000), flag);
        if (ret <= 0)
        {
            printf("errno=%d failed info:%s\n", errno, strerror(errno));
            if ((errno == ENOBUFS) || (errno == EINTR))
            {
                usleep(1000);
                continue;
            }

            if (++retrycount > RETRY_SEND)
            {
                _mutex.unlock();
                return bytes_sent;
            }
            usleep(10000);
        }
        else
        {
            bytes_sent += ret;
        }
    }
    while (bytes_sent < len);
    //printf("bytes_sent = %d\n", (int)bytes_sent);
    _mutex.unlock();
    return bytes_sent;
}

int CSocketMgr::sock_recv(int sock_fd, char *buf, unsigned int *len, int flag)
{
    int i = 0;
    int msg_size = 0;
    int ret = 0;
    int bytes_left;
    int bytes_read;
    int net_flag = 1;
    int length_flag = 1;
    struct timeval tv;

    tv.tv_sec = 2;
    tv.tv_usec = 0;
    bytes_left = (int)(*len);

    _mutex.lock();
    setsockopt(sock_fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));

    do
    {
        while((bytes_read = recv(sock_fd, buf, bytes_left, flag)) == -1 && errno == EINTR);
        if(bytes_read < 0)
        {
            printf("recv_msg %s %d\n", strerror(errno), errno);
            ret = -1;
            net_flag = 0;
            goto finial_exit;
        }
        if ((bytes_read >= 8) && (i == 0))
        {
            i++;
            memcpy(&msg_size, buf + 4, 4);
        }

        /*add code*/
        if (msg_size > (int)*len)
        {
            length_flag = 0;
            printf("length is not enough!\n");
            goto finial_exit;
        }
        /*add code*/

        bytes_left -= bytes_read;
        buf += bytes_read;
    } while ((int)*len - bytes_left < msg_size);

finial_exit:
    if (!net_flag)
    {
        _mutex.unlock();
        return ret;
    }
    if (!length_flag)
    {
        _mutex.unlock();
        return -1;
    }
    *len -= bytes_left;
    _mutex.unlock();
    return (*len);
}


/*同步收发接口*/
int CSocketMgr::sync_send_and_recv(const char *ip, int port, const char *send_buf, char *recv_buf, unsigned int send_len, unsigned int *recv_len)
{
    int ret = -1;
    int socket_fd = -1;
    struct timeval tv;
    struct sockaddr_in serv_addr;

    if ((!ip) || (!send_buf) || (!recv_buf))
    {
        printf("there exist NULL pointer\n");
        return -1;
    }

    socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (socket_fd == -1)
    {
        printf("create socket failed: %s %d!\n", strerror(errno), errno);
        return -1;
    }

    tv.tv_sec = 3;
    tv.tv_usec = 0;
    setsockopt(socket_fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
    setsockopt(socket_fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));

    printf("sockMgr's ip = %s  port = %d\n", ip, port);
    bzero(&serv_addr,sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(port);        
    serv_addr.sin_addr.s_addr = inet_addr(ip);

    ret = sock_connect(socket_fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    if (ret == -1)
    {
        printf("socket connect %s failed, the reason is %s\n", ip, strerror(errno));
        close(socket_fd);
        return -1;
    }

    ret = sock_send(socket_fd, (char *)send_buf, send_len, 0);
    if (ret < (int)send_len)
    {
        printf("failed to send info\n");
        close(socket_fd);
        return -1;
    }

    ret = sock_recv(socket_fd, recv_buf, recv_len, 0);   //需要后续考虑recv_buf
    if (ret < 0)
    {
        printf("failed to recv info\n");
        close(socket_fd);
        return -1;
    }
    if (socket_fd > 0)
    {
        close(socket_fd);
    }
    return 0;
}

/*同步发送接口*/
int CSocketMgr::sync_send(char const *ip, int port, const char *buf, int len)
{
    int ret = -1;
    int socket_fd = -1;
    struct timeval tv;
    struct sockaddr_in serv_addr;

    if ((!ip) || (!buf))
    {
        printf("there exist NULL pointer\n");
        return -1;
    }

    socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (socket_fd == -1)
    {
        printf("create socket failed: %s %d!\n", strerror(errno), errno);
        return -1;
    }

    tv.tv_sec = 2;
    tv.tv_usec = 0;
    setsockopt(socket_fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));

    bzero(&serv_addr,sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(port);        
    serv_addr.sin_addr.s_addr = inet_addr(ip);

    ret = sock_connect(socket_fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    if (ret == -1)
    {
        close(socket_fd);
        return -1;
    }

    ret = sock_send(socket_fd, (char *)buf, len, 0);
    if (ret < len)
    {
        printf("failed to send info\n");
        close(socket_fd);
        return -1;
    }

    if (socket_fd > 0)
    {
        close(socket_fd);
    }
    return 0;
}

void CSocketMgr::sock_close( int *fd )
{
    if(*fd <= 0)
        return;
    close(*fd);
    *fd = -1;
}

一个使用该类实现网络监听的例子example.h

#include "SocketMgr.h"

#define UNIX_DOMAIN "/tmp/unix.domain"//我们创建一个本地域套接字

class CLocalListener
{
public:
    CLocalListener(void);
    ~CLocalListener(void);

    //我们只演示如何用公共类开启一个本地监听服务
    int start_local_service();

private:
    int ser_sock_fd;
    pthread_t recv_thread;
    int _socket;//本地socket
    CSocketMgr _sock_mgr;
};
具体实现example.cpp
int CLocalListener::start_local_service()
{

    int ret = -1;
    ObjectFd object_fd;//封装的fd结构体
    struct sockaddr_un serv_addr;
    fsock_info local_watch_sock[MAXSOCKFD];

    memset(local_watch_sock, 0, sizeof(local_watch_sock));  
    ser_sock_fd = _sock_mgr.sock_create(AF_UNIX, SOCK_STREAM, 0);//创建本地套接字
    if (ser_sock_fd == -1)
    {
        perror("socket failed!");
        return NAZ_ERR_SOCK_ERROR;
    }

    bzero(&serv_addr,sizeof(serv_addr));
    serv_addr.sun_family = AF_UNIX;
    unlink(UNIX_DOMAIN);
    memcpy(serv_addr.sun_path, UNIX_DOMAIN, sizeof(serv_addr.sun_path) - 1);//设置绑定所需的参数
    ret = _sock_mgr.sock_bind(ser_sock_fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));//绑定套接字
    if (ret == -1)
    {
        perror("bind failed!");
        close(ser_sock_fd);
        return NAZ_ERR_SOCK_ERROR;
    }
    _sock_mgr.sock_listen(ser_sock_fd, MAXSOCKFD);//监听套接字

    object_fd.watch_sock = local_watch_sock;
    object_fd._sock_mgr = _sock_mgr;
    //创建接收线程，满足多个请求连接到该套接字的情况
    if (pthread_create(&recv_thread, NULL, _sock_mgr.s_recv_routine, (void *)&object_fd) != 0)
    {
        perror("pthread_create failed:\n");
        close(ser_sock_fd);
        return (-1);
    }
    //accept，将accept的套接字更新到local_watch_sock数组中，由上边的recv线程收取并采取相应的操作
    _sock_mgr.accept_routine(ser_sock_fd, local_watch_sock, 0);
    pthread_join(recv_thread, NULL);

    if (ser_sock_fd > 0)
    {
        close(ser_sock_fd);
    }

    return 0;
}
EthanCoding
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
套接字编程（Socket）c++实现源码
10-24
socket编程 c++源码 实现两台机器建立socket连接，进行数据报文的传输！
关于复用套接字
lyclowlevel的专栏
02-16 880
可以通过WSADuplicateSocket在进程内共享套接字，但是在什么时候调用closesocket关闭套接字，却没有明确的做法。   之前，我是在进程退出时统一关闭这些套接字。但是，这种做法会在极少数的XP+IE6环境下崩溃（必崩）。至今，原因未明。   由于套接字
【C++】套接字（socket）
最新发布
qq_38801607的博客
05-23 364
在C++中，使用套接字（socket）进行网络编程涉及到创建、绑定、监听、连接和数据传输等操作。以下是详细介绍和示例代码，说明如何在C++中使用套接字进行网络编程。通常，使用的头文件是和等。这些头文件在大多数Unix-like系统（包括Linux和macOS）上都可以找到。Windows系统上需要使用头文件，并进行一些特定的初始化操作。
I/O复用套接字编程
stone-jin
12-23 500
1.当前文章的目的是让自己熟练使用select poll epoll 2.select
linux套接字之端口复用
ma_de_hao_mei_le的博客
07-24 540
这样不同线程中的socket就可以使用自己的套接字来调用accept函数来接收客户端数据，在这之前，多线程服务器应用中所有的线程都是用同一个套接字调用accept。值得注意的一点是，连接的分配是由一个四元组确定的，即clientIP、clientPort、serverIP、serverPort。对于以前的单套接字方式，如果来自客户端的流量特别大，比如说每秒40000个连接，是完全承受不住的，响应速度会变得非常慢。另外一个弊端就是，在多线程应用中，所有的线程一般都通过如下的循环来接收来自客户端的连接。...
(一)C++的并发世界欢迎你
爱拼才会赢
10-06 1480
1、并发是什么？？？ 1.1最通俗的理解，是指两个或两个以上的独立活动同时发生。 1.2计算机中并发：单个系统同时执行多个独立的并发任务。 单个处理器实现并发的方式成为 “任务切换(task switching) ”, 实际上并不是真正的并发。 这是通过计算机内部每秒多次切换任务，实际上每一时刻只有一个任务被cpu执行，因为多个任务执行间隔时间很多，计算机都不断切换这些任务，所以给人感觉，这
C语言理解套接字
siying8419的博客
04-09 1151
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; #include&lt;errno.h&gt; #include&lt;sys/types.h&gt; #include&lt;sys/socket.h&gt; #include&lt;netinet/in.h&gt; #d
socket套接字封装
04-06
用c++封装的套接字，封装了客服端和服务端，如果想要更深入的了解底层的套接字实现可以去看看，如果不了解也可以直接调用。比较容易上手
套接字端口复用:SO_REUSEADDR
小米的修行之路
06-21 1451
下面建立的套接字都是tcp套接字1.进程创建监听套接字socket1，邦定一个指定端口，并接受了若干连接。那么进程创建另外一个套接口socket2，并试图邦定同一个端口时候，bind错误返回“Address already in use”（即使使用了SO_REUSEADDR）.2.进程创建监听套接字，邦定一个指定端口，并接受了若干连接，为每个连接创建子进程为连接服务。杀死监听套接字所在进程，然后重...
socket UDP TCP 的一些用法
老衣的专栏
08-05 3449
UDP 用最通俗的话讲，所谓UDP，就是发送出去就不管的一种网络协议。因此UDP编程的发送端只管发送就可以了，不用检查网络连接状态。下面用例子来说明怎样编写UDP，并会详细解释每个API和数据类型。 7.1 UDP广播发送程序 下面是一个用UDP发送广播报文的例
C++使用socket套接字的通信编程实现
PandaLHC
09-14 6773
最近在写一个小的服务器， 几百的并发， 边做边学习。 本文是转载 作者：心里正在嘀咕 程序代码：  链接: http://pan.baidu.com/s/1geMsmfL                             http://pan.baidu.com/s/1kV4Pq2z                             http://pan.baidu.c
C++中 socket 套接字连接
一个一般人发现不了的博客
01-26 5156
建立socket连接 套接字之间的连接过程分为三个步骤：服务器监听，客户端请求，连接确认。 第一步：服务器监听：服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态，等待客户端的连接请求。 第二步：客户端请求：指客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端套接字的地址和端口
Linux下的多路复用和unix套接字的综合使用
u011430213的专栏
04-06 1096
多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备好读写时，即返回可操作的描述符的数目，以下场合经常使用： （1）当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。 （2）当一个客户同时处理多个套接口时，而这种情况是可能的，但很少出现。 （3）如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复用。 （4）如果一个服务器即
C++套接字函数
qq_45220555的博客
01-06 276
Winsocket套接字 #include "winsock2.h" //引用头文件 #pragma comment(lib,"ws2_32.lib") //链接库文件 WSDATA wsd; //定义WSADATA对象
什么是套接字（Socket）、多路复用和多路分解？
LauvMiracle的博客
01-29 2747
多数应用程序是由通信进程对组成，每对中的两个进程互相发送报文。从一个进程向另一个进程发送的报文必须通过下面的网络。 进程通过一个称为套接字的软件接口（一个进程有一个或多个套接字，每个都有唯一的标识符）向网络发送报文和从网络接受报文。套接字是同一台主机内应用层与运输层之间的接口，由于套接字是建立网络应用程序的可编程接口，所以也叫做应用程序编程接口。 举例子： 进程比作房子，套接字比作门。当一个进程向另一台主机的进程发送报文时，它把报文推出门，报文经过运输到达目的进程的门，接受进程的门（套接字）传递给目的进程。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值