linux网络编程 多并发服务器

实现linux多并发服务器(epoll)
wrap.h

#ifndef _WRAP_H_
#define _WRAP_H_

#include <arpa/inet.h>

void perr_exit(const char *s);
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
int Bind(int fd, const struct sockaddr *sa, socklen_t salen);
int Connect(int fd, const struct sockaddr *sa, socklen_t salen);
int Listen(int fd, int backlog);
int Socket(int family, int type, int protocol);
ssize_t Read(int fd, void *ptr, size_t nbytes);
ssize_t Write(int fd, const void *ptr, size_t nbytes);
int Close(int fd);
ssize_t Readn(int fd, void *vptr, size_t n);
ssize_t Writen(int fd, const void *vptr, size_t n);
ssize_t my_read(int fd, char *ptr);
ssize_t Readline(int fd, void *vptr, size_t maxlen);

#endif

wrap.c

#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include <error.h>
#include <stdio.h>
void perr_exit(const char *s)
{
    perror(s);
    exit(1);
}
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
    int n;
// accept:阻塞，是慢系统调用。可能会被信息中断
again:
    if ((n = accept(fd, sa, salenptr)) < 0)
    {
        if ((errno == ECONNABORTED) || (errno == EINTR))
        {
            goto again; // 重启
        }
        else
        {
            perr_exit("accept error");
        }
    }
    return n;
}
int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
    int n;
    if ((n = bind(fd, sa, salen)) < 0)
    {
        perr_exit("bind error");
    }
    return n;
}
int Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
    int n;
    if ((n = connect(fd, sa, salen)) < 0)
    {
        perr_exit("connect error");
    }
    return n;
}
int Listen(int fd, int backlog)
{
    int n;
    if ((n = listen(fd, backlog)) < 0)
    {
        perr_exit("listen error");
    }
    return n;
}
int Socket(int family, int type, int protocol)
{
    int n;
    if ((n = socket(family, type, protocol)) < 0)
    {
        perr_exit("socket error");
    }
    return n;
}
ssize_t Read(int fd, void *ptr, size_t nbytes)
{
    ssize_t n;
again:
    if ((n = read(fd, ptr, nbytes)) == -1)
    {
        if (errno == EINTR) // 被中断
        {
            goto again;
        }
        else
        {
            return -1;
        }
    }
    return n;
}
ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
    ssize_t n;
again:
    if ((n = write(fd, ptr, nbytes)) == -1)
    {
        if (errno == EINTR)
        {
            goto again;
        }
        else
        {
            return -1;
        }
    }
    return n;
}
int Close(int fd)
{
    int n;
    if ((n = close(fd)) == -1)
    {
        perr_exit("close error");
    }
    return n;
}
ssize_t Readn(int fd, void *vptr, size_t n)
{
    size_t nleft;
    ssize_t nread;
    char *ptr;
    ptr = vptr;
    nleft = n;

    while (nleft > 0)
    {
        if ((nleft = read(fd, ptr, nleft)) < 0)
        {
            if (errno == EINTR)
            {
                nread = 0;
            }
            else
            {
                return -1;
            }
        }
        else if (nread == 0)
        {
            break;
        }
        nleft -= nread;
        ptr += nread;
    }
    return n - nleft;
}
ssize_t Writen(int fd, const void *vptr, size_t n)
{
    size_t nleft;
    ssize_t nwritten;
    const char *ptr;
    ptr = vptr;
    nleft = n;

    while (nleft > 0)
    {
        if ((nwritten = write(fd, ptr, nleft)) <= 0)
        {
            if (nwritten < 0 && errno == EINTR)
            {
                nwritten = 0;
            }
            else
            {
                return -1;
            }
        }
        nleft -= nwritten;
        ptr += nwritten;
    }
    return n;
}
static ssize_t my_read(int fd, char *ptr)
{
    static int read_cnt;
    static char *read_ptr;
    static char read_buf[100];

    if (read_cnt <= 0)
    {
    again:
        if ((read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0)
        {
            if (errno == EINTR)
            {
                goto again;
            }
            return -1;
        }
        else if (read_cnt == 0)
        {
            return 0;
        }
        read_ptr = read_buf;
    }
    read_cnt--;
    *ptr = *read_ptr++;
    return 1;
}
ssize_t Readline(int fd, void *vptr, size_t maxlen)
{
    ssize_t n, rc;
    char c, *ptr;
    ptr = vptr;

    for (n = 1; n < maxlen; n++)
    {
        if ((rc = my_read(fd, &c)) == 1)
        {
            *ptr++ = c;
            if (c == '\n')
            {
                break;
            }
        }
        else if (rc == 0)
        {
            *ptr = 0;
            return n - 1;
        }
        else
        {
            return -1;
        }
    }
    *ptr = 0;
    return n;
}

server.c

#include <stdio.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <ctype.h>
#include <sys/epoll.h>
#include <arpa/inet.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 8080
#define OPEN_MAX 1024

int main(void)
{

    int i, n, j, ret;
    // 创建套接字
    int listenfd = Socket(AF_INET, SOCK_STREAM, 0);
    // 绑定
    struct sockaddr_in servaddr;
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(SERV_PORT);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    int opt = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));
    Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
    // 设置监听
    Listen(listenfd, 20);
    // epoll
    int client[OPEN_MAX];
    int maxi = -1;

    for (i = 0; i < OPEN_MAX; ++i)
    {
        client[i] = -1;
    }

    // 创建一个 epoll 句柄
    int efd = epoll_create(OPEN_MAX);
    if (efd == -1)
    {
        perr_exit("epoll_create");
    }
    // 设置连接
    int nready;
    struct epoll_event tep, ep[OPEN_MAX];
    tep.events = EPOLLIN;
    tep.data.fd = listenfd;
    ret = epoll_ctl(efd, EPOLL_CTL_ADD, listenfd, &tep);
    if (ret == -1)
    {
        perr_exit("epoll_ctl");
    }

    // 客户端信息
    struct sockaddr_in cliaddr;
    socklen_t cliaddr_len;
    char str[INET_ADDRSTRLEN];
    int connfd, sockfd;
    char buf[MAXLINE];

    while (1)
    {
        nready = epoll_wait(efd, ep, OPEN_MAX, -1); //-1表示阻塞
        if (nready == -1)
        {
            perr_exit("epoll_wait");
        }

        for (i = 0; i < nready; ++i)
        {
            if (!ep[i].events & EPOLLIN)
            {
                continue;
            }
            if (ep[i].data.fd == listenfd) // 有新客户端连接
            {
                cliaddr_len = sizeof(cliaddr);
                connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
                printf("连接来自 %s 在端口 %d\n",
                       inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)), ntohs(cliaddr.sin_port));

                for (j = 0; j < OPEN_MAX; ++j)
                {
                    if (client[j] < 0)
                    {
                        client[j] = connfd;
                        break;
                    }
                }
                if (j == OPEN_MAX)
                {
                    perr_exit("too many clients");
                }
                if (j > maxi)
                {
                    maxi = j;
                }

                tep.events = EPOLLIN;
                tep.data.fd = connfd;
                ret = epoll_ctl(efd, EPOLL_CTL_ADD, connfd, &tep);
                if (ret == -1)
                {
                    perr_exit("epoll_ctl");
                }
                // if(--nready <= 0)
                // {
                //     continue;
                // }
            }
            else
            {
                sockfd = ep[i].data.fd;
                n = Read(sockfd, buf, MAXLINE);
                if (n == 0)
                {
                    for (j = 0; j <= maxi; ++j)
                    {
                        if (client[j] == sockfd)
                        {
                            client[j] = -1;
                            break;
                        }
                    }
                    ret = epoll_ctl(efd, EPOLL_CTL_DEL, sockfd, NULL);
                    if (ret == -1)
                    {
                        perr_exit("epoll_ctl");
                    }
                    Close(sockfd);
                    printf("cliend[%d] closed connect\n", j);
                }
                else
                {
                    printf("read: %s 连接来自 %s 在端口 %d\n", buf, inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)), ntohs(cliaddr.sin_port));
                    for (j = 0; j < n; ++j)
                    {
                        buf[j] = toupper(buf[j]);
                    }
                    Writen(sockfd, buf, n);
                    memset(buf, 0, sizeof(buf));
                }
            }
        }
    }

    Close(listenfd);
    Close(efd);

    return 0;
}