update

CMakeLists.txt

@@ -10,6 +10,6 @@ include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}/include
 )
 
-add_executable(test1
+add_executable(web
-    src/test1.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/web.cpp
 )

include/asyncio.hpp

@@ -0,0 +1,3 @@
+namespace zt{
+    
+}

include/demo.hpp

@@ -0,0 +1,58 @@
+#include <coroutine>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+
+namespace zt {
+    namespace demo{
+        template<class T>
+        struct Promise;
+
+        template<class T>
+        struct coroutine: std::coroutine_handle<Promise<T>>{
+            using promise_type = Promise<T>;
+        };
+
+        struct RAII{
+            std::string name;
+            RAII(const std::string &s):name(s){
+                std::cout<<__FUNCTION__<<" "<<s<<'\n';
+            }
+            ~RAII(){
+                std::cout<<__FUNCTION__<<" "<<name<<'\n';
+            }
+        };
+
+        template<class T=void>
+        struct Promise{
+            Promise():raii("in promise"){};
+            RAII raii;
+            auto initial_suspend(){
+                std::cout<<__FUNCTION__<<'\n';
+                return std::suspend_always{};
+                // return std::suspend_never{};
+            }
+            auto final_suspend()noexcept{//最后要不要把句柄执行权限归还，如果不归还，那么协程被销毁，继续检查.done()则Segmentation fault
+                std::cout<<__FUNCTION__<<'\n';
+                return std::suspend_always{};
+            }
+            void unhandled_exception(){
+                std::cout<<__FUNCTION__<<'\n';
+                throw std::runtime_error("unhandled exeception\n");
+            }
+            void return_value(const std::decay_t<T> &t){
+                std::cout<<__FUNCTION__<<' '<<t<<'\n';
+            }
+            coroutine<T> get_return_object(){
+                std::cout<<__FUNCTION__<<'\n';
+                return {coroutine<T>::from_promise(*this)};
+            }
+            auto yield_value(const std::decay_t<T> &t){
+                std::cout<<__FUNCTION__<<' '<<t<<'\n';
+                return std::suspend_always{};
+            }
+            coroutine<T> h;
+        };
+    }
+}

src/test1.cpp

@@ -1,75 +0,0 @@
-#include <coroutine>
-#include <iostream>
-#include <stdexcept>
-#include <string>
-#include <type_traits>
-
-template<class T>
-struct Promise;
-
-template<class T>
-struct coroutine: std::coroutine_handle<Promise<T>>{
-    using promise_type = ::Promise<T>;
-};
-
-struct RAII{
-    std::string name;
-    RAII(const std::string &s):name(s){
-        std::cout<<__FUNCTION__<<" "<<s<<'\n';
-    }
-    ~RAII(){
-        std::cout<<__FUNCTION__<<" "<<name<<'\n';
-    }
-};
-
-template<class T=void>
-struct Promise{
-    Promise():raii("in promise"){};
-    RAII raii;
-    auto initial_suspend(){
-        std::cout<<__FUNCTION__<<'\n';
-        return std::suspend_always{};
-        // return std::suspend_never{};
-    }
-    auto final_suspend()noexcept{//最后要不要把句柄执行权限归还，如果不归还，那么协程被销毁，继续检查.done()则Segmentation fault
-        std::cout<<__FUNCTION__<<'\n';
-        return std::suspend_always{};
-    }
-    void unhandled_exception(){
-        std::cout<<__FUNCTION__<<'\n';
-        throw std::runtime_error("unhandled exeception\n");
-    }
-    void return_value(const std::decay_t<T> &t){
-        std::cout<<__FUNCTION__<<' '<<t<<'\n';
-    }
-    coroutine<T> get_return_object(){
-        std::cout<<__FUNCTION__<<'\n';
-        return {coroutine<T>::from_promise(*this)};
-    }
-    auto yield_value(const std::decay_t<T> &t){
-        std::cout<<__FUNCTION__<<' '<<t<<'\n';
-        return std::suspend_always{};
-    }
-    coroutine<T> h;
-};
-
-
-
-coroutine<int> test(){
-    RAII raii("in test");
-    std::cout<<"testing\n";
-    co_yield 1;
-    co_yield 2;
-    co_return 0;
-}
-
-int main(){
-    std::cout<<__FUNCTION__<<'\n';
-    auto handle = test();
-    std::cout<<__FUNCTION__<<'\n';
-    while (!handle.done()) {
-        handle.resume();
-        std::cout<<__FUNCTION__<<'\n';
-    }
-    handle.destroy();//如果不destroy()那么~RAII in promise将不会显示，也不能将destroy()交给~Promise()管理，也不会~RAII in promise
-}

src/web.cpp

@@ -0,0 +1,173 @@
+#include <iostream>
+#include <strings.h>
+#include <sys/socket.h>
+#include <sys/epoll.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+
+using namespace std;
+
+#define MAXLINE 5
+#define OPEN_MAX 100
+#define LISTENQ 20
+#define SERV_PORT 5000
+#define INFTIM 1000
+
+void setnonblocking(int sock)
+{
+    int opts;
+    opts=fcntl(sock,F_GETFL);
+    if(opts<0)
+    {
+        perror("fcntl(sock,GETFL)");
+        exit(1);
+    }
+    opts = opts|O_NONBLOCK;
+    if(fcntl(sock,F_SETFL,opts)<0)
+    {
+        perror("fcntl(sock,SETFL,opts)");
+        exit(1);
+    }
+}
+
+int main(int argc, char* argv[])
+{
+    int i, maxi, listenfd, connfd, sockfd,epfd,nfds, portnumber;
+    ssize_t n;
+    char line[MAXLINE];
+    socklen_t clilen;
+
+
+    if ( 2 == argc )
+    {
+        if( (portnumber = atoi(argv[1])) < 0 )
+        {
+            fprintf(stderr,"Usage:%s portnumber/a/n",argv[0]);
+            return 1;
+        }
+    }
+    else
+    {
+        fprintf(stderr,"Usage:%s portnumber/a/n",argv[0]);
+        return 1;
+    }
+
+
+
+    //声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件
+
+    struct epoll_event ev,events[20];
+    //生成用于处理accept的epoll专用的文件描述符
+
+    epfd=epoll_create(256);
+    struct sockaddr_in clientaddr;
+    struct sockaddr_in serveraddr;
+    listenfd = socket(AF_INET, SOCK_STREAM, 0);
+    //把socket设置为非阻塞方式
+
+    //setnonblocking(listenfd);
+
+    //设置与要处理的事件相关的文件描述符
+
+    ev.data.fd=listenfd;
+    //设置要处理的事件类型
+
+    ev.events=EPOLLIN|EPOLLET;
+    //ev.events=EPOLLIN;
+
+    //注册epoll事件
+
+    epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);
+    bzero(&serveraddr, sizeof(serveraddr));
+    serveraddr.sin_family = AF_INET;
+    char *local_addr="127.0.0.1";
+    inet_aton(local_addr,&(serveraddr.sin_addr));//htons(portnumber);
+
+    serveraddr.sin_port=htons(portnumber);
+    bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr));
+    listen(listenfd, LISTENQ);
+    maxi = 0;
+    for ( ; ; ) {
+        //等待epoll事件的发生
+
+        nfds=epoll_wait(epfd,events,20,500);
+        //处理所发生的所有事件
+
+        for(i=0;i<nfds;++i)
+        {
+            if(events[i].data.fd==listenfd)//如果新监测到一个SOCKET用户连接到了绑定的SOCKET端口，建立新的连接。
+
+            {
+                connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen);
+                if(connfd<0){
+                    perror("connfd<0");
+                    exit(1);
+                }
+                //setnonblocking(connfd);
+
+                char *str = inet_ntoa(clientaddr.sin_addr);
+                cout << "accapt a connection from " << str << endl;
+                //设置用于读操作的文件描述符
+
+                ev.data.fd=connfd;
+                //设置用于注测的读操作事件
+
+                ev.events=EPOLLIN|EPOLLET;
+                //ev.events=EPOLLIN;
+
+                //注册ev
+
+                epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);
+            }
+            else if(events[i].events&EPOLLIN)//如果是已经连接的用户，并且收到数据，那么进行读入。
+
+            {
+                cout << "EPOLLIN" << endl;
+                if ( (sockfd = events[i].data.fd) < 0)
+                    continue;
+                if ( (n = read(sockfd, line, MAXLINE)) < 0) {
+                    if (errno == ECONNRESET) {
+                        close(sockfd);
+                        events[i].data.fd = -1;
+                    } else
+                        std::cout<<"readline error"<<std::endl;
+                } else if (n == 0) {
+                    close(sockfd);
+                    events[i].data.fd = -1;
+                }
+                line[n] = '/0';
+                cout << "read " << line << endl;
+                //设置用于写操作的文件描述符
+
+                ev.data.fd=sockfd;
+                //设置用于注测的写操作事件
+
+                ev.events=EPOLLOUT|EPOLLET;
+                //修改sockfd上要处理的事件为EPOLLOUT
+
+                //epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
+
+            }
+            else if(events[i].events&EPOLLOUT) // 如果有数据发送
+
+            {
+                sockfd = events[i].data.fd;
+                write(sockfd, line, n);
+                //设置用于读操作的文件描述符
+
+                ev.data.fd=sockfd;
+                //设置用于注测的读操作事件
+
+                ev.events=EPOLLIN|EPOLLET;
+                //修改sockfd上要处理的事件为EPOLIN
+
+                epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
+            }
+        }
+    }
+    return 0;
+}