网络编程,socket基础

最新推荐文章于 2023-05-17 16:48:28 发布
最新推荐文章于 2023-05-17 16:48:28 发布
阅读量184 收藏
点赞数
分类专栏： 网络编程 C++ 文章标签： 网络 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29798479/article/details/126407483
版权

TCP三次握手

        发生在协议栈中，只要服务器相应的端口处于listen状态就可连接，不属于应用态

网络IO模型

1.一个进程多个线程

 优点：逻辑简单，缺点：不适合大量的客户端请求，阻塞较多（accept + recv都是阻塞的），不知道connfd到底属于哪个线程，解决方法：使用IO多路复用，将这个工作交给组件（select，epoll等）去实现

难以突破C10k

2.一个进程一个select

能做到C10k,难以做到C1000K

3.rector模型

IO多路复用

select原理：一个client一个fd,通过select来选择有事件发生的fd,比特位来判断是否有事件发生（fd_set ，一个比特集合的数据结构），select五个参数

内部，先初始化一个表示事件的发生与否的fd_set，通过FD_ZERO将fd_set置0，然后注册

代码

fd_set rdfs;
FD_ZERO(&rdfs);
FD_SET(listenfd,rdfs);

select代码

int main(int argc, char *argv[])
{
    if (argc <= 2)
    {
        printf("usage:  ip_address port_number\n");
        return 1;
    }
    const char *ip = argv[1];
    int port = atoi(argv[2]);

    struct sockaddr_in address;
    bzero(&address, sizeof(address));
    address.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &address.sin_addr);
    address.sin_port = htons(port);

    int sock = socket(PF_INET, SOCK_STREAM, 0);
    assert(sock >= 0);

    int ret = bind(sock, (struct sockaddr *)&address, sizeof(address));
    assert(ret != -1);
    ret = listen(sock, 5);
    assert(ret != -1);
    //两个fdset，一个注册给内核，一个用户使用
    fd_set rfds, rset,wfds,wset;
    //将内核中的相应位全部置0
    FD_ZERO(&rfds);
    FD_ZERO(&wfds);
    char buff[MAX_LEN];
    //注册listenfd到内核
    FD_SET(sock, &rfds);
    //循环侦听
    int connfd;
    int max_fd = sock;
    int n;
    while (1) {

		rset = rfds;
		wset = wfds;

		int nready = select(max_fd+1, &rset, &wset, NULL, NULL);


		if (FD_ISSET(sock, &rset)) { //

			struct sockaddr_in client;
		    socklen_t len = sizeof(client);
		    if ((connfd = accept(sock, (struct sockaddr *)&client, &len)) == -1) {
		        printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
		        return 0;
		    }

			FD_SET(connfd, &rfds);

			if (connfd > max_fd) max_fd = connfd;

			if (--nready == 0) continue;

		}

		int i = 0;
		for (i = sock+1;i <= max_fd;i ++) {

			if (FD_ISSET(i, &rset)) { // 
				n = recv(i, buff, MAX_LEN, 0);
		        if (n > 0) {
		            buff[n] = '\0';
		            printf("recv msg from client: %s\n", buff);
					FD_SET(i, &wfds);

					//reactor
					//send(i, buff, n, 0);
		        } else if (n == 0) { //

					FD_CLR(i, &rfds);
					//printf("disconnect\n");
		            close(i);
					
		        }
				if (--nready == 0) break;
			} 
            else if (FD_ISSET(i, &wset)) {
                printf("inter the send %d \n",i);
				send(i, buff, n, 0);
				FD_SET(i, &rfds);

                //这里要将写的fd清除出去，否则服务器会一直发
                FD_CLR(i,&wfds);
				if (--nready == 0) break;
			}
		}
    }

    close(sock);
    return 0;
}

poll代码

 struct pollfd fds[POLL_SIZE] = {0};
    fds[0].fd = sock;
    fds[0].events = POLLIN;
    while (1)
    {
        int nready = poll(fds, max_fd, -1);
        if (fds[0].revents & POLLIN)
        {
            struct sockaddr_in client;
            socklen_t len = sizeof(client);
            if ((connfd = accept(sock, (struct sockaddr *)&client, &len)) == -1)
            {
                printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
                return 0;
            }
            fds[connfd].fd = connfd;
            fds[connfd].events = POLLIN;
            if (connfd > max_fd)
            {
                max_fd = connfd;
            }
            if (--nready == 0)
            {
                continue;
            }
        }

        int i = 0;
        for (i = sock + 1; i <= max_fd; ++i)
        {
            if (fds[i].revents & POLLIN)
            {
                n = recv(i, buff, MAX_LEN, 0);
                if (n > 0)
                    buff[n] = '\0';
                fds[i].events = POLLOUT;
            }
            else if (fds[i].revents & POLLOUT)
            {
                send(i, buff, n, 0);
                fds[i].events = POLLIN;
            }
        }
    }

epoll代码：                

int epfd = epoll_create(1);
    //存储活跃的event
    struct epoll_event events[POLL_SIZE] = {0};

    //处理连接的事件
    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = sock;
    //将处理连接的端口加入进去
    epoll_ctl(epfd, EPOLL_CTL_ADD, sock, &ev);
    while (1)
    {
        int nready = epoll_wait(epfd, events, POLL_SIZE, 5);
        if (nready == -1)
        {
            continue;
        }
        int i = 0;
        for (i = 0; i < nready; ++i)
        {   
            if (events[i].data.fd == sock)
            {
                struct sockaddr_in client;
                socklen_t len = sizeof(client);
                if ((connfd = accept(sock, (struct sockaddr *)&client, &len)) == -1)
                {
                    printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
                    return 0;
                }
                ev.events = EPOLLIN;
                ev.data.fd = connfd;
                epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);
            }
            else if(events[i].events & EPOLLIN)
            {   
                int n =  recv(events[i].data.fd,buff,MAX_LEN,0);
                buff[n] = '\0';
                ev.events = EPOLLOUT;
                ev.data.fd = events[i].data.fd;
                epoll_ctl(epfd,EPOLL_CTL_MOD,ev.data.fd,&ev);
            }
            else if(events[i].events & EPOLLOUT){
                send(events[i].data.fd,buff,n,0);
                events[i].events = EPOLLIN;
                epoll_ctl(epfd,EPOLL_CTL_MOD,events[i].data.fd,&events[i]);
            }
        }
    }

epoll原理：

基于io/fd/socket，

epoll_create()：创建epoll事件。

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/epoll.h>
#include <string.h>
#include <pthread.h>
#include <sys/poll.h>
#define MAX_LEN 1024
#define MAX_EPOLL_EVENT 1024
#define POLL_SIZE 1024


typedef int NCALLBACK(int fd, int event, void *arg);
int ncreator_del(int fd, NCALLBACK cb, int event, void *arg);
//设置回调函数
// epoll池中管理的对象
typedef struct nitem
{
    int fd;
    //事件，通过int来表示
    int events;
    void *arg;
    //一个回调函数的情况,epoll处理时判断可读还是可写

    //两个回调函数，两者可以并存
    NCALLBACK *readcb;
    NCALLBACK *writecb;
    NCALLBACK *accpetcb;
    // ASCII大于0,只需要存储大于0的情况
    unsigned char sbuff[MAX_LEN];
    int slenght;
    unsigned char rbuff[MAX_LEN];
    int rlength;
} nitem;

typedef struct itemblock
{
    struct itemblock *next;
    nitem *items;
} itemblock;

//链表+数组方式来存储事件
struct reactor
{
    int epfd;
    itemblock *first; 
};


int nreactor_set_event(int fd, NCALLBACK cb, int event, void *arg);
int init_reactor(struct reactor *r)
{
    int epfd = epoll_create(1);
    // fd与item的关系为直接的数组下标
    r->first = (struct itemblock *)malloc(sizeof(itemblock));
    r->epfd = epfd;
    if (r->first == NULL)
    {
        close(epfd);
        return -2;
    }
    memset(r->first, 0, sizeof(itemblock));
    //分配事件
    r->first->items = (nitem *)malloc(MAX_EPOLL_EVENT * sizeof(nitem));
    if (r->first->items == NULL)
    {   
        close(epfd);
        return -2;
    }
    memset(r->first->items, 0,(MAX_EPOLL_EVENT * sizeof(nitem)));
    r->first->next = NULL;
    return 0;
}
//单例模式的全局reactor
struct reactor *g_reactor = NULL;
struct reactor *getinstance(void)
{
    if (g_reactor == NULL)
    {
        g_reactor = (struct reactor *)malloc(sizeof(struct reactor));
        if (NULL == g_reactor)
        {
            return NULL;
        }
        memset(g_reactor, 0, sizeof(struct reactor));
        if (init_reactor(g_reactor) < 0)
        {
           return NULL;
        }
    }
    return g_reactor;
}
#define NO_SET_CB 0
#define READ_CB 1
#define WRITE_CB 2
#define ACCEPT_CB 3

int read_callback(int fd,int event,void *arg);
int write_callback(int fd,int event,void *arg){
    struct reactor * r = getinstance();
    unsigned char *sbuff = r->first->items[fd].sbuff;
    int length = r->first->items[fd].slenght;
    int ret = send(fd,sbuff,length,0);
    if(ret < length){
        nreactor_set_event(fd,write_callback,WRITE_CB,NULL);
    }
    else{
        nreactor_set_event(fd,read_callback,READ_CB,NULL);
    }
    return 0;
}

int read_callback(int fd,int event,void *arg){
    struct reactor * r = getinstance();
    unsigned char *buffer = r->first->items[fd].rbuff;
#if 0
    while(index < MAX_LEN){
        ret = recv(fd,buffer+index,MAX_LEN - index,0);
        if(ret == -1){
            //break;
        }
        else if(ret > 0){
            index += ret;
            //加入到
            nreactor_set_event(fd,read_callback,READ_CB,NULL);
        }
        else{
           // break;
        }
    //}
#endif
    int ret = recv(fd,buffer,MAX_LEN,0);
    if(ret == 0){
        ncreator_del(fd,NULL,0,NULL);
        close(fd);
    }
    else if(ret > 0){
        unsigned char * sbuffer = r->first->items[fd].sbuff;
        memcpy(sbuffer,buffer,ret);
        r->first->items[fd].slenght = ret;
        printf("read cb : %s\n",sbuffer);
        nreactor_set_event(fd,write_callback,WRITE_CB,NULL);
    }
}

int accpet_callback(int fd, int event, void *arg)
{
    struct sockaddr_in client;
    socklen_t len = sizeof(client);
    int connfd;
    if ((connfd = accept(fd, (struct sockaddr *)&client, &len)) == -1)
    {
        printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }
    printf("accept sucess\n");
    nreactor_set_event(connfd,read_callback,READ_CB,NULL);
}





int init_server(int port)
{
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    assert(sock != -1);
    struct sockaddr_in address;
    bzero(&address, sizeof(address));
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = htonl(INADDR_ANY);
    address.sin_port = htons(port);
    assert(sock >= 0);
    int ret = bind(sock, (struct sockaddr *)&address, sizeof(address));
    assert(ret != -1);
    ret = listen(sock, 10);
    assert(ret != -1);
    return sock;
}

int nreactor_set_event(int fd, NCALLBACK cb, int event, void *arg)
{
    struct reactor *r = getinstance();
    struct epoll_event ev = {0};
    

    if (event == READ_CB)
    {
        r->first->items[fd].fd = fd;
        r->first->items[fd].readcb = cb;
        r->first->items[fd].arg = arg;
        ev.events = EPOLLIN;
    }
    else if (event == WRITE_CB)
    {
        r->first->items[fd].fd = fd;
        r->first->items[fd].writecb = cb;
        r->first->items[fd].arg = arg;
        ev.events = EPOLLOUT;
    }
    else if (event == ACCEPT_CB)
    {
        r->first->items[fd].fd = fd;
        r->first->items[fd].accpetcb = cb;
        r->first->items[fd].arg = arg;
        ev.events = EPOLLIN;
    }
    ev.data.ptr = &r->first->items[fd]; 
    if(r->first->items[fd].events == NO_SET_CB){
        if (epoll_ctl(r->epfd, EPOLL_CTL_ADD, fd, &ev) < 0) {
			printf("epoll_ctl EPOLL_CTL_ADD failed, %d\n", errno);
			return -1;
		}
		r->first->items[fd].events = event;
    }
    else if(r->first->items[fd].events != event){
        if (epoll_ctl(r->epfd, EPOLL_CTL_MOD, fd, &ev) < 0) {
			printf("epoll_ctl EPOLL_CTL_MOD failed\n");
			return -1;
		}
		r->first->items[fd].events = event;
    }
    return 0;
}

int reactor_loop(int listenfd){ 
    struct epoll_event events[MAX_EPOLL_EVENT] = {0};
    struct reactor* r = getinstance();
    while (1)
    {
        int nready = epoll_wait(r->epfd, events, POLL_SIZE, 5);
        if (nready == -1)
        {
            continue;
        }
        int i = 0;
        for (i = 0; i < nready; ++i)
        {   
            struct nitem *item = (struct nitem *)events[i].data.ptr;
            int connfd = item->fd;
            if (connfd == listenfd)
            {
                item->accpetcb(listenfd,0,NULL);
            }
            else{
                if(events[i].events & EPOLLIN){
                    item->readcb(connfd,0,NULL);
                }
                if(events[i].events &EPOLLOUT){
                    item->writecb(connfd,0,NULL);
                }
            }
        }
    }
    return 0;
}

int ncreator_del(int fd, NCALLBACK cb, int event, void *arg){
    struct reactor * r = getinstance();
    struct epoll_event ev = {0};
    ev.data.ptr = arg;
    epoll_ctl(r->epfd,EPOLL_CTL_DEL,fd,&ev);
    r->first->items[fd].events = 0;
    return 0;
}

int main(int argc, char *argv[])
{
    //两个fdset，一个注册给内核，一个用户使用
    char buff[MAX_LEN];
    //封装到init_server函数中
    int listenfd = init_server(8080);
    //将监听端口连接加入到epoll中
    nreactor_set_event(listenfd, accpet_callback, ACCEPT_CB, NULL);
    reactor_loop(listenfd);
    close(listenfd);
    return 0;
}

        

c++终结者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
socket创建失败_linux下socket采用epoll编程demo
weixin_39631467的博客
11-25 198
首先，需要调用epoll_create创建epoll； 此后我们就可以进行socket/bind/listen； 然后调用epoll_ctl进行注册； 接下来，就可以通过一个while(1)循环调用epoll_wait来等待事件的发生； 然后循环查看接收到的事件并进行处理； 1)如果事件是sever的socketfd我们就要进行accept，并且把接收到client的socketfd加入到要监听的...
linux使用epoll进行socket编程
路过的熊的博客
09-04 830
linux使用epoll进行socket编程
Linux网络编程—Day7
gxy的博客
05-17 80
socket基础API
【转载】socket编程常用函数解析
tecoes的博客
07-05 760
这里以一个socket通信例子讲解socket的函数，server.cpp 是服务器端代码，client.cpp 是客户端代码，要实现的功能是：客户端从服务器读取一个字符串并打印出来。 服务器端代码 server.cpp： #include <stdio.h> #include <string.h> #include <stdlib.h> #include <unistd.h> #include <arpa/inet.h> #inclu
【Linux Posix】（20）网络编程III - 网络编程socket
风浪云HH的博客
02-27 850
目录 网络服务器编程模型 socket bind listen connect accept send_recv send和recv函数 服务器例子和客户端例子 服务器 客户端 网络服务器编程模型 函数名称 函数简单描述 附加说明 socket 创造某种类型的套接字 bind 将一个 socket 绑定一个ip与端口的二元组上 listen 将一个 socket 变为侦听状态 connect ...
Linux网络通信编程socket
11-21
通过学习为后续Linux网络编程奠定基础。首先介绍网络编程的概念，即网络协议分层，旨在帮助读者对网络建立初步的、全面立体的认识，其次介绍包括协议、端口、地址等；最后介绍应用非常广泛的传输控制协议...
java网络编程 socket的TCP应用编程
01-09
- Java Socket类和ServerSocket类是进行TCP网络编程的核心API。 - ServerSocket用于创建服务器端的套接字，监听特定端口的连接请求。 - Socket用于创建客户端的套接字，与服务器建立连接。 3. **服务端编程**： ...
python socket 网络编程
01-19
一、Python Socket基础 Python中的socket模块源于C语言的socket接口，它提供了TCP/IP协议族的网络通信功能。在Python中，创建一个socket对象是网络编程的第一步，通常使用`socket.socket()`函数来完成。你可以指定...
Linux-socket网络编程基础完整版资料.ppt
11-13
Linux Socket 网络编程基础 Linux Socket 网络编程基础是指在 Linux 操作系统中使用 Socket 编程技术来实现网络通信的基础知识。它涵盖了 Socket 的定义、 Socket 的类型、网络协议、数据包头信息、BSD Socket 网络...
网络编程+Socket+聊天室+项目
最新发布
02-26
在IT领域，网络编程是构建分布式系统的基础，而Socket编程是网络编程的核心组成部分。本项目以"网络编程+Socket+聊天室"为主题，旨在通过一个实际的Java项目，帮助开发者理解并掌握网络通信的基本原理和Socket的应用...
Linux网络编程【一】：TCP socket套接字详解
Begin
05-26 8290
1.socket socket这个词可以表示很多概念: 在TCP/IP协议中,“IP地址+TCP或UDP端口号”唯一标识网络通讯中的一个进程,“IP地址+端口号”就称为 socket。 在TCP协议中,建立连接的两个进程各自有一个socket来标识,那么这两个socket组成 的socketpair就唯一标识一个连接。 socket本身 有“插座”的意思,因此用来描述网络连接的一 对一关系
Linux高性能服务器之poll应用（16）
qq_62309585的博客
08-31 349
poll的应用
Socket选项的那些事（一）
LastDays_UIT技术分享
08-26 1410
今天跟大家分享套接字选项的一些事情，以下就是要详细介绍的东西，通过实际的编程来分享这些东西，有什么问题或者错误欢迎来讨论哈！！！！！ SOL_SOCKET协议族选项（通用地址族选项） IPPROTO_ TCP和IPPROTO_ IP选项 ioctl（）函数 OK，进入我们今天的分享，先来讲述SOL_SOCKET协议族选项（通用地址族选项）获取和设置套接字选项其实在进行网络编程的时候，我们需要经常去查
《Linux高性能服务器编程》学习笔记
weixin_44708428的博客
03-01 246
1. 监听socket int listen(int sockfd, int backlog); 作用：创建一个监听队列来存放待处理的客户连接（在队列中就已经处于ESTABLISHED而不用accept返回以后)。backlog参数提示内核监听队列的最大长度，如果队列长度超过backlog，则不受理新的客户连接，和客户端也会收到ECONNREFUSED的错误信息。 处于监听队列中的连接至少完成了三次握手中的两步，如果超出backlog的是SYN_RCVD，如果在backlog内则是ESTABLISHE
网络socket编程相关函数
萬象森羅，能者獨秀！
06-10 530
网络socket编程相关函数socket函数socket函数为系统创建一个套接字，应用程序通过访问该函数创建的套接字实现对数据的发送和接收。 函数原型如下：如果函数调用成功，会返回一个标识这个套接字的文件描述符，失败的时候返回-1#include<sys/types.h> #include<sys/socket.h> int socket(int domain, int type, int pro
Linux - 第13节 - 网络编程套接字（二）
qq_45113223的博客
05-13 759
netstat -lntp命令可以看到我们服务器程序tcpServer的网络状态，Proto是服务类型这里为tcp的，Recv-Q是收到的消息数这里为0，Send-Q是发送的消息数这里为0，Local是本地绑定的IP地址这里是0.0.0.0，即任意地址绑定，Address是绑定的端口号这里是8080，Foreign为允许访问的远端主机IP，这里为任何远端主机，Address为允许访问的远端主机的端口，这里为任何远端主机的端口，State为当前套接字状态，这里为监听状态LISTEN。
断言(assert)的用法
qq_35029633的博客
12-12 873
断言(assert)的用法 阅读rabbitmq -c源码时学到了不少，梳理一下一些知识点。 assert宏的原型在assert.h头文件里面。 #include <assert.h> void assert( int expression ); 作用是计算计算表达式 expression ，若其值为假（即为0），则先向 stderr 打印异常信息，然后调用 abort 终止...
bzero
zmldlut的专栏
03-15 4778
原型：extern void bzero（void *s, int n）;　　 用法：#include 　　 功能：置字节字符串s的前n个字节为零且包括‘\0’。　　 说明：bzero无返回值，并且使用strings.h头文件，strings.h曾经是posix标准的一部分，但是在POSIX.1-2001标准里面，这些函数被标记为了遗留函数而不推荐使用。在POSIX.1-2008标准里已经没
Linux编程之select
weixin_34010566的博客
06-26 1217
select系统调用的的用途是：在一段指定的时间内，监听用户感兴趣的文件描述符上可读、可写和异常等事件。 select 机制的优势 为什么会出现select模型？ 先看一下下面的这句代码： int iResult = recv(s, buffer,1024); 这是用来接收数据的，在默认的阻塞模式下的套接字里，recv会阻塞在那里，直到套接字连接上有数据可读，把数据读到buffer里后recv函数...
C# Socket网络编程基础教程
1. **Socket基础**：Socket是操作系统提供的一个接口，它允许应用程序通过网络协议（如TCP/IP）进行数据传输。在C语言中，Socket API提供了创建、连接、监听、接受和发送数据等功能。 2. **TCP与UDP**：TCP...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值