libevent::实现的低级 socket

LibEvent 实现的低级 ROT13  例子

#include <cstdio>
#include <netinet/in.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <event2/event.h>
#include <assert.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>  

#define MAX_LINE 16384

struct fd_state
{
    char buffer[MAX_LINE];
    size_t buffer_used;
    size_t n_written;
    size_t write_upto;
    struct event*read_event;
    struct event*write_event;
};

void run(void);
void do_accept(evutil_socket_t listener, short event, void*arg);
struct fd_state* alloc_fd_state(struct event_base*base, evutil_socket_t fd);
void do_read(evutil_socket_t fd, short events, void*arg);
void do_write(evutil_socket_t fd, short events, void*arg);
void free_fd_state(struct fd_state*state);

char rot13_char(char c)
{
    if ((c >= 'a'  &&  c <= 'm ') || (c >= 'A ' && c <= 'M '))
        return c + ;
    else if ((c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z'))
        return c - ;
    else
        return c;
}

int main(int c, char**v)
{
    run();
    return ;
}

void run(void)
{
    evutil_socket_t listener;
    struct sockaddr_in sin;
    struct event_base*base;
    struct event*listener_event;
    base = event_base_new();
    if (!base)
        return;

    sin.sin_family = AF_INET; sin.sin_addr.s_addr = ;
    sin.sin_port = htons();
    listener = socket(AF_INET, SOCK_STREAM, );
    evutil_make_socket_nonblocking(listener);
    /*#ifndef WIN32
        {
            int one = 1;
            setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
        }
    #endif    */
    if (bind(listener, (struct sockaddr*) &sin, sizeof(sin)) < )
    {
        perror("bind"); return;
    }
    if (listen(listener, ) < )
    {
        perror("listen");
        return;
    }
    listener_event = event_new(base, listener, EV_READ | EV_PERSIST, do_accept, (void*)base);

    event_add(listener_event, NULL);
    event_base_dispatch(base);
}

void do_accept(evutil_socket_t listener, short event, void*arg)
{
    struct event_base*base = (event_base*)(arg);
    struct sockaddr_storage ss;
    socklen_t slen = sizeof(ss);
    int fd = accept(listener, (struct sockaddr*) &ss, &slen);
    if (fd < )
    {
        perror("accept");
    }
    else if (fd > FD_SETSIZE)
    {
        close(fd);
    }
    else
    {
        struct fd_state* state;

        evutil_make_socket_nonblocking(fd);

        state = alloc_fd_state(base, fd);
        assert(state);
        assert(state->write_event);
        event_add(state->read_event, NULL);
    }
}

struct fd_state* alloc_fd_state(struct event_base*base, evutil_socket_t fd)
{
    fd_state* state = (fd_state*)malloc(sizeof(fd_state));
    if (!state) return NULL;
    state->read_event = event_new(base, fd, EV_READ | EV_PERSIST, do_read, state);
    if (!state->read_event)
    {
        free(state); return NULL;
    }
    state->write_event = event_new(base, fd, EV_WRITE | EV_PERSIST, do_write, state);
    if (!state->write_event)
    {
        event_free(state->read_event);
        free(state);
        return NULL;
    }
    state->buffer_used = state->n_written = state->write_upto = ;
    assert(state->write_event);
    return state;
}

void do_read(evutil_socket_t fd, short events, void*arg)
{
    struct fd_state*state = (fd_state*)arg;
    int i;
    ssize_t result;
    while ()
    {
        char buf[] = { '\0' };
        assert(state->write_event);
        result = recv(fd, buf, sizeof(buf), );
        if (result <= )
            break;

        printf("buf = [ %s ]\n", buf);

        assert(state->write_event);
        event_add(state->write_event, NULL);
        state->write_upto = state->buffer_used;

        for (i = ; i < result; ++i)
        {
            if (state->buffer_used < sizeof(state->buffer))
                state->buffer[state->buffer_used++] = rot13_char(buf[i]);

            if (buf[i] == '\n')
            {
                assert(state->write_event);
                event_add(state->write_event, NULL);
                state->write_upto = state->buffer_used;
            }
        }
    }
    if (result == )
    {
        free_fd_state(state);
    }
    else if (result < )
    {
        if (errno == EAGAIN)
            return;

        perror("recv");
        free_fd_state(state);
    }
}

void do_write(evutil_socket_t fd, short events, void*arg)
{
    struct fd_state*state = (fd_state*)arg;
    while (state->n_written < state->write_upto)
    {
        ssize_t result = send(fd, state->buffer + state->n_written, state->write_upto - state->n_written, );
        if (result < )
        {
            if (errno == EAGAIN)
                return;

            free_fd_state(state);
            return;
        }
        assert(result != );
        state->n_written += result;
    }
    if (state->n_written == state->buffer_used)
    {
        state->n_written = state->write_upto = state->buffer_used = ;
    }
    event_del(state->write_event);
}

void free_fd_state(struct fd_state*state)
{
    event_free(state->read_event);
    event_free(state->write_event);
    free(state);
}