#include <string.h>

 #include <errno.h>

 #include <stdio.h>

 #include <signal.h>

 #include <stdlib.h>

 #include <event2/bufferevent.h>

 #include <event2/buffer.h>

 #include <event2/listener.h>

 #include <event2/util.h>

 #include <event2/event.h>

 #include <sys/un.h>

 #include <unistd.h>

 #define MAX_LINE 16384

 static const char MESSAGE[] = "Hello, World!\n";

 static const char PATH[] = "./roura";

 static void listener_cb(evutil_socket_t, short, void *);

 static void conn_read_cb(struct bufferevent *, void *);

 static void conn_write_cb(struct bufferevent *, void *);

 static void conn_event_cb(struct bufferevent *, short, void *);

 static void signal_cb(evutil_socket_t, short, void *);

 static char rot13_char(char);

 int main(int argc, char **argv) {

 	struct event_base *base;

 	evutil_socket_t listener;

 	struct event *listener_event;

 	struct event *signal_event;

 	struct sockaddr_un sun;

 	setvbuf(stdout, NULL, _IONBF, 0);

 	base = event_base_new();

 	if (!base) {

 		fprintf(stderr, "Could not initialize libevent!\n");

 		return 1;

 	}

 	memset(&sun, 0, sizeof (sun));

 	sun.sun_family = AF_UNIX;

 	strcpy(sun.sun_path, PATH);

 	listener = socket(AF_UNIX, SOCK_STREAM, 0);

 	evutil_make_socket_nonblocking(listener);

 	if (bind(listener, (struct sockaddr*) &sun, sizeof (sun)) < 0) {

 		fprintf(stderr, "Could not create domain socket: %s!\n", PATH);

 		return 1;

 	}

 	if (listen(listener, 16) < 0) {

 		fprintf(stderr, "Could not listen\n");

 		return 1;

 	}

 	listener_event = event_new(base, listener, EV_READ | EV_PERSIST, listener_cb, (void*) base);

 	if (!listener_event) {

 		fprintf(stderr, "Could not do event_new\n");

 		return 1;

 	}

 	event_add(listener_event, NULL);

 	signal_event = evsignal_new(base, SIGINT, signal_cb, (void *) base);

 	if (!signal_event || event_add(signal_event, NULL) < 0) {

 		fprintf(stderr, "Could not create/add a signal event!\n");

 		return 1;

 	}

 	event_base_dispatch(base);

 	event_free(listener_event);

 	event_free(signal_event);

 	event_base_free(base);

 	// smažeme soket na disku / soubor -- jinak by program příště spadl na evconnlistener_new_bind()

 	unlink(PATH);

 	printf("done\n");

 	return 0;

 }

 static void listener_cb(evutil_socket_t listener, short event, void *user_data) {

 	struct event_base *base = (event_base *) user_data;

 	struct bufferevent *bev;

 	struct sockaddr_storage ss;

 	socklen_t slen = sizeof (ss);

 	int fd = accept(listener, (struct sockaddr*) &ss, &slen);

 	if (fd < 0) {

 		fprintf(stderr, "Unable to accept(): %d", fd);

 		return;

 	} else if (fd > FD_SETSIZE) {

 		close(fd);

 		return;

 	}

 	evutil_make_socket_nonblocking(fd);

 	bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);

 	if (!bev) {

 		fprintf(stderr, "Error constructing bufferevent!");

 		event_base_loopbreak(base);

 		return;

 	}

 	bufferevent_setcb(bev, conn_read_cb, conn_write_cb, conn_event_cb, NULL);

 	bufferevent_setwatermark(bev, EV_READ, 0, MAX_LINE);

 	bufferevent_enable(bev, EV_READ | EV_WRITE);

 	printf("někdo se k nám připojil! / %p\n", bev);

 	bufferevent_write(bev, MESSAGE, strlen(MESSAGE));

 }

 static void conn_read_cb(struct bufferevent *bev, void *user_data) {

 	/* This callback is invoked when there is data to read on bev. */

 	struct evbuffer *input = bufferevent_get_input(bev);

 	struct evbuffer *output = bufferevent_get_output(bev);

 	struct event_base *base = (event_base *) user_data;

 	size_t len = evbuffer_get_length(input);

 	char *data;

 	/*

 	data = (char*) malloc(len);

 	evbuffer_copyout(input, data, len);

 	 */

 	size_t n;

 	int i;

 	while ((data = evbuffer_readln(input, &n, EVBUFFER_EOL_LF))) {

 		for (i = 0; i < n; ++i)

 			data[i] = rot13_char(data[i]);

 		evbuffer_add(output, data, n);

 		evbuffer_add(output, "\n", 1);

 		free(data);

 	}

 	printf("we got some data...\n");

 	/*

 	if (memcmp(data, "exit\n", len) == 0) {

 		struct timeval delay = {2, 123};

 		event_base_loopexit(base, &delay);

 	}

 	 */

 	if (evbuffer_get_length(input) >= MAX_LINE) {

 		/* Too long; just process what there is and go on so that the buffer

 		 * doesn't grow infinitely long. */

 		char buf[1024];

 		while (evbuffer_get_length(input)) {

 			int n = evbuffer_remove(input, buf, sizeof (buf));

 			for (i = 0; i < n; ++i)

 				buf[i] = rot13_char(buf[i]);

 			evbuffer_add(output, buf, n);

 		}

 		evbuffer_add(output, "\n", 1);

 	}

 	/* Copy all the data from the input buffer to the output buffer. */

 	/*

 	evbuffer_add_buffer(output, input);

 	free(data);

 	 */

 }

 static void conn_write_cb(struct bufferevent *bev, void *user_data) {

 	struct evbuffer *output = bufferevent_get_output(bev);

 	if (evbuffer_get_length(output) == 0) {

 		printf("flushed answer / %p\n", bev);

 		/* nebudeme ukončovat spojení

 		bufferevent_free(bev);

 		 */

 	}

 }

 static void conn_event_cb(struct bufferevent *bev, short events, void *user_data) {

 	if (events & BEV_EVENT_EOF) {

 		printf("Connection closed.\n");

 	} else if (events & BEV_EVENT_ERROR) {

 		printf("Got an error on the connection: %s\n", strerror(errno));

 	}

 	// None of the other events can happen here, since we haven't enabled timeouts

 	bufferevent_free(bev);

 }

 static void signal_cb(evutil_socket_t sig, short events, void *user_data) {

 	struct event_base *base = (event_base *) user_data;

 	struct timeval delay = {2, 123};

 	printf("Zachycen SIGINT (Ctrl+C); ukončuji program během %ld sekund a %ld mikrosekund.\n", delay.tv_sec, delay.tv_usec);

 	event_base_loopexit(base, &delay);

 }

 static char rot13_char(char c) {

 	/* We don't want to use isalpha here; setting the locale would change

 	 * which characters are considered alphabetical. */

 	if ((c >= 'a' && c <= 'm') || (c >= 'A' && c <= 'M'))

 		return c + 13;

 	else if ((c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z'))

 		return c - 13;

 	else

 		return c;

 }