libevent/Sanity/basic/test-libevent.c

/*
# SPDX-License-Identifier: LGPL-2.1+
# ~~~
#   Description: libevent tests
#
#   Author: Susant Sahani <susant@redhat.com>
#   Copyright (c) 2018 Red Hat, Inc.
# ~~~
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/time.h>
#include <event2/event.h>
#include <event2/dns.h>
#include <event2/listener.h>
#include <event2/bufferevent.h>
#include <event2/buffer.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <pthread.h>
#include <sys/time.h>
#include <signal.h>
#include <assert.h>

#define UNIX_SOCK_PATH "/var/run/mysocket"

void evdns_cb(int result, char type, int count, int ttl, void *addresses, void *arg) {
	unsigned char *addr = (char *) addresses;
        int i;

        assert(result == DNS_ERR_NONE);

        printf("type: %s", type == DNS_IPv4_A ? "DNS_IPv4_A" : type == DNS_PTR ? "DNS_PTR" : "DNS_IPv6_AAAA");
        printf("ttl:  %d", ttl);

        for(i = 0 ; i < count ; i++)
                printf("address[%d]:%d.%d.%d.%d\n", i + 1, addr[0 + i*4], addr[1 + i*4], addr[2 + i*4], addr[3 + i*4]);

	evdns_base_clear_nameservers_and_suspend((struct evdns_base *) arg);
}

void test_dns_resolve_ipv4(void) {
        struct event_base *event_base = NULL;
        struct evdns_base *evdns_base = NULL;
        struct evdns_request *req;

	assert((event_base = event_base_new()));
	assert((evdns_base =  evdns_base_new(event_base,  0)));

	assert(evdns_base_resolv_conf_parse(evdns_base, DNS_OPTION_NAMESERVERS, "/etc/resolv.conf") == 0);

        assert(evdns_base_count_nameservers(evdns_base) > 0);

	assert((req = evdns_base_resolve_ipv4(evdns_base, "redhat.com", 0, evdns_cb, evdns_base)));

	event_base_dispatch(event_base);

	event_base_free(event_base);
	evdns_base_free(evdns_base, 0);
}

static int signal_test;
static void signal_cb(evutil_socket_t fd, short event, void *arg) {
	struct event *signal = arg;

        assert(arg);

        signal_test = 1;
        event_base_loopexit((struct event_base *) arg, NULL);

}

void test_signal(void){
	struct event *signal_int;
	struct event_base* base;
        pthread_t client_thread;

	base = event_base_new();
	assert((signal_int = evsignal_new(base, SIGUSR1, signal_cb, base)));

	event_add(signal_int, NULL);
        raise(SIGUSR1);
	event_base_dispatch(base);

        assert(signal_test == 1);

	event_free(signal_int);
	event_base_free(base);
}

void test_event_reader_timer_callback(int fd, short event, void *arg) {
        event_base_loopexit((struct event_base *) arg, NULL);
        assert(0);
}

void *writer_client_thread(void *p) {
        struct sockaddr_un addr;
        struct sockaddr_un from;
        char buf[8192];
        int fd;

        assert((fd = socket(PF_UNIX, SOCK_STREAM, 0)) >= 0);

        memset(&addr, 0, sizeof(addr));
        addr.sun_family = AF_UNIX;
        strcpy(addr.sun_path, UNIX_SOCK_PATH);

        assert(connect(fd, (struct sockaddr *)&addr, sizeof(addr)) >= 0);

        strcpy(buf, "test");
        assert(send(fd, buf, strlen(buf) + 1, 0) >= 0);

        close(fd);

        return 0;
}

static void echo_read_cb(struct bufferevent *bev, void *ctx) {
        struct evbuffer *input = bufferevent_get_input(bev);
        struct evbuffer *output = bufferevent_get_output(bev);
        struct event_base *base = bufferevent_get_base(bev);
        size_t len = evbuffer_get_length(input);
        static char client_buf[64];

        assert(input);
        assert(output);
        assert(base);
        assert(len > 0);

        assert(evbuffer_copyout(input, client_buf, len) >= 0);
        assert(evbuffer_add_buffer(output, input) >= 0);

        assert(!strcmp(client_buf, "test"));

        unlink(UNIX_SOCK_PATH);
        event_base_loopexit(base, NULL);
}

static void echo_event_cb(struct bufferevent *bev, short events, void *ctx) {

        if (events & BEV_EVENT_ERROR)
                perror("Error from bufferevent");

        if (events & (BEV_EVENT_EOF | BEV_EVENT_ERROR)) {
                bufferevent_free(bev);
        }

        assert(0);
}

static void accept_conn_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *address, int socklen, void *ctx) {
        struct event_base *base = evconnlistener_get_base(listener);
        struct bufferevent *bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);

        assert(base);
        assert(bev);

        bufferevent_setcb(bev, echo_read_cb, NULL, echo_event_cb, NULL);
        bufferevent_enable(bev, EV_READ | EV_WRITE);
}

static void accept_error_cb(struct evconnlistener *listener, void *ctx) {
        struct event_base *base = evconnlistener_get_base(listener);
        int err = EVUTIL_SOCKET_ERROR();

        assert(base);

        fprintf(stderr, "Got an error %d (%s) on the listener. Shutting down.\n", err, evutil_socket_error_to_string(err));

        assert(0);
        event_base_loopexit(base, NULL);
}

void test_event_reader(void) {
        struct evconnlistener *listener;
        struct timeval three_sec = { 3, 0 };
        struct event_base *base;
        struct sockaddr_un sin;
        pthread_t client_thread;
        struct itimerval tval;
        struct event *ev;

        assert((base = event_base_new()));
        assert((ev = event_new(base, -1, EV_TIMEOUT, test_event_reader_timer_callback, (void *) base)));
        event_add(ev, &three_sec);

        memset(&sin, 0, sizeof(sin));
        sin.sun_family = AF_LOCAL;
        strcpy(sin.sun_path, UNIX_SOCK_PATH);

        assert((listener = evconnlistener_new_bind(base, accept_conn_cb, NULL,
                                                            LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, -1,
                                                            (struct sockaddr *) &sin, sizeof(sin))));
        evconnlistener_set_error_cb(listener, accept_error_cb);

        assert(pthread_create(&client_thread, NULL, *writer_client_thread, (void *) NULL) >= 0);
        event_base_dispatch(base);

        sleep(1);

        pthread_join(client_thread, NULL);
}

void test_timer_callback(int fd, short event, void *arg) {
        int *x = (int *) arg;

        *x = 10;
}

void test_timer(void) {
        struct timeval one_sec = { 1, 0 };
        struct event_base *base;
        struct event *ev;
        static int x;

        assert((base = event_base_new()));
        assert((ev = event_new(base, -1, EV_TIMEOUT, test_timer_callback, (void *) &x)));
        event_add(ev, &one_sec);
        event_base_dispatch(base);

        sleep(2);
        assert(10 == x);
}

int main(int argc, char *argv[]) {
        test_timer();
        test_event_reader();
        test_signal();
        test_dns_resolve_ipv4();
}