libev && non-blocking

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

/* port we're listening on */
#define PORT 2020


static struct SBind {
    int fdmax;								/* maximum file descriptor number */
    int listener;							/* listening socket descriptor */
    int newfd;								/* newly accept()ed socket descriptor */

    fd_set master;							/* str_bind.master file descriptor list */
    fd_set read_fds;							/* temp file descriptor list for select() */

    int yes;								/* for setsockopt() SO_REUSEADDR, below */
    uint addrlen;
} str_bind;

static void *accepter(void *_arg)
{
    struct sockaddr_in clientaddr;					/* client address */

    char buf[1024];							/* buffer for client data */
    int nbytes, i;
    long n = (long)_arg;

    /* main loop */
    while (1) {
	str_bind.read_fds = str_bind.master;				/* copy it */

	if (select(str_bind.fdmax+1, &str_bind.read_fds, NULL, NULL, NULL) == -1) {
	    perror("Server-select() error lol!");
	    exit(1);
	}
	printf("%ld: Server-select() is OK...\n", n);

	/*run through the existing connections looking for data to be read*/
	for (i = 0; i <= str_bind.fdmax; i++) {
	    if (FD_ISSET(i, &str_bind.read_fds)) {			/* we got one... */
		if (i == str_bind.listener) {
		    /* handle new connections */
		    str_bind.addrlen = sizeof(clientaddr);

		    if ((str_bind.newfd = accept(str_bind.listener, (struct sockaddr *)&clientaddr, &str_bind.addrlen)) == -1)
			perror(" Server-accept() error lol!");
		    else {
			printf("%ld: Server-accept() is OK...\n", n);

			FD_SET(str_bind.newfd, &str_bind.master); 	/* add to str_bind.master set */
			if (str_bind.newfd > str_bind.fdmax)		/* keep track of the maximum */
			    str_bind.fdmax = str_bind.newfd;

			printf("%ld:  New connection from %s on socket %d\n", n, inet_ntoa(clientaddr.sin_addr), str_bind.newfd);
		    }
		} else {
		    /* handle data from a client */
		    if ((nbytes = recv(i, buf, sizeof(buf), 0)) <= 0) {
			/* got error or connection closed by client */
			if (nbytes == 0) 				/* connection closed */
			    printf(" socket %d hung up\n", i);
			else
			    perror("recv() error lol!");

			close(i);					/* close it... */
			FD_CLR(i, &str_bind.master);			/* remove from str_bind.master set */
		    } else {
			sprintf(buf, "Hi");
			send(i, buf, strlen(buf), 0);

			close(i);					/* close it... */
			FD_CLR(i, &str_bind.master);			/* remove from str_bind.master set */
		    }
		}
	    }
	}
    }
}

static int binding()
{
    struct sockaddr_in serveraddr;					/* server address */

    /* clear the str_bind.master and temp sets */
    FD_ZERO(&str_bind.master);
    FD_ZERO(&str_bind.read_fds);

    /* get the str_bind.listener */
    if ((str_bind.listener = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
	perror("Server-socket() error lol!");
	return 1;							/*just exit lol!*/
    }

    printf("Server-socket() is OK...\n");
    /*"address already in use" error message */
    if (setsockopt(str_bind.listener, SOL_SOCKET, SO_REUSEADDR, &str_bind.yes, sizeof(int)) == -1) {
	perror("Server-setsockopt() error lol!");
	return 1;
    }
    printf("Server-setsockopt() is OK...\n");

    /* bind */
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr.s_addr = INADDR_ANY;
    serveraddr.sin_port = htons(PORT);
    memset(&(serveraddr.sin_zero), '\0', 8);

    if (bind(str_bind.listener, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) == -1) {
	perror("Server-bind() error lol!");
	return 1;
    }
    printf("Server-bind() is OK...\n");

    /* listen */
    if (listen(str_bind.listener, 40) == -1) {
	perror("Server-listen() error lol!");
	return 1;
    }
    printf("Server-listen() is OK...\n");

    FD_SET(str_bind.listener, &str_bind.master);			/* add the str_bind.listener to the str_bind.master set */

    /* keep track of the biggest file descriptor */
    str_bind.fdmax = str_bind.listener; /* so far, it's this one*/

    return 0;
}

int main(int argc, char *argv[])
{
    pthread_t thread_accepter;

    str_bind.yes = 1;

    if (binding() != 0) {
	printf("Error binding.\n");
	return 0;
    }

    pthread_create( &thread_accepter, NULL, accepter, (void *)0);
    pthread_create( &thread_accepter, NULL, accepter, (void *)1);
    pthread_create( &thread_accepter, NULL, accepter, (void *)2);
    pthread_create( &thread_accepter, NULL, accepter, (void *)3);

    getchar();

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <fcntl.h>
#include <errno.h>
#include <ev.h>

struct ev_loop *loop;
long minfd, maxfd, fds[4096];


static void *sender(void *_arg)
{
	time_t now;
	char *ct, buf[1024];
	long i;

	while (1) {
		now = time(NULL);
		ct = ctime(&now);
		sprintf(buf, "%ld: %s\n", (long)_arg, ct);

		for (i = minfd; i <= maxfd; i++)
			if (fds[i] == 1) {
				write(i, buf, strlen(buf));
				printf("sended to fd %ld\n", i);
			}

		sleep((long)_arg);
	}

	return 0;
}

void read_connection(EV_P_ struct ev_io *w, int revents)
{
	int size, buf_size = 1024;
	char buf[1024];
	printf("%s loop %p ev_io %p revents %i (fd %i)\n", __PRETTY_FUNCTION__, EV_A_ w, revents, w->fd);
	size = read(w->fd, buf, buf_size);

	if (size <= 0) {
		if( size == -1 && errno == EAGAIN )
			printf("\t EAGAIN\n");

		fds[(long)w->fd] = 0;
		ev_io_stop(loop, w);
		close(w->fd);
		free(w);
		printf("\t -> closed connection (fd %i)\n", w->fd);

		return;
	}

	write(w->fd, "Hi\n", strlen("Hi\n"));
}

void accept_connection(EV_P_ struct ev_io *w, int revents)
{
	printf("%s loop %p ev_io %p revents %i (fd %i)\n", __PRETTY_FUNCTION__, EV_A_ w, revents, w->fd);
	struct ev_io *io = malloc(sizeof(struct ev_io));
	struct sockaddr sa;
	socklen_t sizeof_sa = sizeof(sa);
	long fd = accept(w->fd, &sa, &sizeof_sa);
	if (fd <= 0) return;

	fds[fd] = 1;
	printf("fds[%ld] = 1;\n", fd);

	if (fd > maxfd)
		maxfd = fd;

	fcntl(fd, F_SETFL, O_NONBLOCK);
	ev_io_init(io, read_connection, fd, EV_READ);
	ev_io_start(loop, io);
}

int main()
{
	pthread_t thread_sender;
	struct sockaddr_in addr;
	int fd;

	pthread_create( &thread_sender, NULL, sender, (void *)5);
	pthread_create( &thread_sender, NULL, sender, (void *)3);

	// Create server socket
	if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
		perror("socket error");
		return -1;
	}

	bzero(&addr, sizeof(addr));
	addr.sin_family = AF_INET;
	addr.sin_port = htons(2020);
	addr.sin_addr.s_addr = INADDR_ANY;

	// Bind socket to address
	if (bind(fd, (struct sockaddr*) &addr, sizeof(addr)) != 0) {
		perror("bind error");
		return -1;
	}

	// Start listing on the socket
	if (listen(fd, 128) < 0) {
		perror("listen error");
		return -1;
	}

	minfd = fd + 1;
	maxfd = minfd;

	loop = ev_default_loop(EVBACKEND_EPOLL);

	struct ev_io *io = malloc(sizeof(struct ev_io));
	ev_io_init(io, accept_connection, fd, EV_READ);
	ev_io_start(loop, io);

	// Start infinite loop
	while (1)
		ev_loop(loop, 10);

	return 0;
}