1. //
    2. // Created by chenshun on 2022/3/21.
    3. //
    5. #include <sys/socket.h>
    6. #include <sys/event.h>
    7. #include <netinet/in.h>
    8. #include <arpa/inet.h>
    9. #include <fcntl.h>
    10. #include <unistd.h>
    11. #include <stdio.h>
    12. #include <string.h>
    13. #include <stdlib.h>
    15. const size_t PAGE = 1024 * 16;
    17. const int kReadEvent = 1;
    18. const int kWriteEvent = 2;
    20. void updateEvent(int kqFd, int fd, int events) {
    21.     struct kevent ke;
    22.     if (events & kReadEvent) {
    23.         EV_SET(&ke, fd, EVFILT_READ, EV_ADD, 0, 0, 0);
    24.         kevent(kqFd, &ke, 1, NULL, 0, NULL);
    25.     }
    26.     if (events & kWriteEvent) {
    27.         EV_SET(&ke, fd, EVFILT_WRITE, EV_ADD, 0, 0, 0);
    28.         kevent(kqFd, &ke, 1, NULL, 0, NULL);
    29.     }
    30. }
    32. void delEvent(int kqFd, int fd, int events) {
    33.     struct kevent ke;
    34.     if (events & kReadEvent) {
    35.         EV_SET(&ke, fd, EVFILT_READ, EV_DELETE, 0, 0, 0);
    36.         kevent(kqFd, &ke, 1, NULL, 0, NULL);
    37.     }
    38.     if (events & kWriteEvent) {
    39.         EV_SET(&ke, fd, EVFILT_WRITE, EV_DELETE, 0, 0, 0);
    40.         kevent(kqFd, &ke, 1, NULL, 0, NULL);
    41.     }
    42. }
    44. void handleAccept(int kq, int socket_fd) {
    45.     struct sockaddr_storage sa;
    46.     socklen_t salen = sizeof(sa);
    47.     int client = accept(socket_fd, (struct sockaddr *) &sa, &salen);
    48.     int flags = fcntl(client, F_GETFL, 0);
    49.     fcntl(client, F_SETFL, flags | O_NONBLOCK);
    50.     updateEvent(kq, client, kReadEvent);
    51. }
    53. void handleRead(int kq, int fd) {
    54.     char buf[PAGE];
    55.     size_t rr = read(fd, &buf, PAGE);
    56.     if (rr == 0) {
    57.         delEvent(kq, fd, kReadEvent | kWriteEvent);
    58.         close(fd);
    59.         return;
    60.     }
    61.     delEvent(kq, fd, kReadEvent);
    62.     if (rr == 6 && !strcmp("exit\r\n", buf)) {
    63.         write(fd, "good bye!\n", strlen("good bye!\n"));
    64.         close(fd);
    65.         return;
    66.     }
    67.     printf("receive bytes: %zu, i have receive your message: %s\n", rr, buf);
    68.     updateEvent(kq, fd, kWriteEvent);
    69. }
    71. void handleWrite(int kq, int fd) {
    72.     char *send = "i have receive your message, expect your next message\n";
    73.     write(fd, send, strlen(send));
    74.     delEvent(kq, fd, kWriteEvent);
    75.     updateEvent(kq, fd, kReadEvent);
    76. }
    78. void loop_once(int kq, int socket_fd, int waitms) {
    79.     struct timespec timeout;
    80.     timeout.tv_sec = waitms / 1000;
    81.     timeout.tv_nsec = (waitms % 1000) * 1000 * 1000;
    83.     struct kevent *event = malloc(sizeof(struct kevent *));
    85.     int retval = kevent(kq, NULL, 0, event, 20, &timeout);
    86.     if (retval > 0) {
    87.         printf("收到事件: %d 件\n", retval);
    88.     }
    89.     for (int i = 0; i < retval; i++) {
    90.         struct kevent ev = event[i];
    91.         uintptr_t fd = ev.ident;
    92.         if (ev.filter == EVFILT_READ) {
    93.             //处理可读时间
    94.             if (fd == socket_fd) {
    95.                 handleAccept(kq, socket_fd);
    96.             } else {
    97.                 handleRead(kq, (int) fd);
    98.             }
    99.         }
    100.         if (ev.filter == EVFILT_WRITE) {
    101.             //处理可写事件
    102.             handleWrite(kq, (int) fd);
    103.         }
    104.     }
    105.     free(event);
    106. }
    109. int main() {
    111.     int port = 19999;
    112.     int socket_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    113.     struct sockaddr_in *serv_addr = malloc(sizeof(struct sockaddr_in));
    114.     if (serv_addr == NULL) {
    115.         printf("分配内存失败");
    116.         exit(1);
    117.     }
    118.     serv_addr->sin_family = AF_INET;
    119.     serv_addr->sin_addr.s_addr = inet_addr("127.0.0.1");
    120.     serv_addr->sin_port = htons(port);
    121.     //
    122.     int on = 1;
    123.     setsockopt(socket_fd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));
    124.     int flags = fcntl(socket_fd, F_GETFL, 0);
    125.     fcntl(socket_fd, F_SETFL, flags | O_NONBLOCK);
    127.     if (bind(socket_fd, (struct sockaddr *) serv_addr, sizeof(struct sockaddr)) < 0) {
    128.         printf("bind 失败!");
    129.         exit(1);
    130.     }
    132.     listen(socket_fd, 20);
    133.     printf("使用telnet 127.0.0.1 19999 来进行测试\n");
    134.     printf("输入exit来断开TCP链接\n");
    135.     int queue = kqueue();
    136.     //注册
    137.     updateEvent(queue, socket_fd, kReadEvent);
    138.     for (;;) {
    139.         loop_once(queue, socket_fd, 10000);
    140.     }
    141.     return 0;
    142. }