libev helloworld

client.c

#include <stdio.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>

#define PORT_NO 4545
#define BUFFER_SIZE 1024

int main(int argc, char *argv[]) {
    int sd;
    struct sockaddr_in addr;
    char buffer[BUFFER_SIZE] = "";
    if(argc < 2) {
        puts("no arguments");
        return -1;
    }
    strcpy(buffer, argv[1]);

// Create client socket
    if( (sd = socket(PF_INET, SOCK_STREAM, 0)) < 0 ) {
        perror("socket error");
        return -1;
    }

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

    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT_NO);
    addr.sin_addr.s_addr =  htonl(INADDR_ANY);

// Connect to server socket
    if(connect(sd, (struct sockaddr *)&addr, sizeof addr) < 0) {
        perror("Connect error");
        return -1;
    }
    puts("connected, sending data");

    // Read input from user and send message to the server
    send(sd, buffer, strlen(buffer), 0);

    puts("waitng for response");
    // Receive message from the server
    recv(sd, buffer, BUFFER_SIZE, 0);
    printf("message: %s\n", buffer);

    return 0;
}

libevecho.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <netinet/in.h>
#include <arpa/inet.h>
#include <ev.h>

#define CHK_ERR(err,s) if ((err)==1) { puts("ERROR "); perror(s); exit(EXIT_FAILURE); }

void accept_cb(struct ev_loop *loop, struct ev_io *watcher, int revents);
void read_cb(struct ev_loop *loop, struct ev_io *watcher, int revents);

int main() {
    int lsock;
    struct sockaddr_in saddr;
    int sport = 4545;

    struct ev_loop *loop = ev_default_loop(0);
    struct ev_io w_accept;

    lsock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    CHK_ERR(lsock, "ERROR on creating socket");
    memset(&saddr, 0, sizeof(saddr));
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(sport);
    saddr.sin_addr.s_addr = INADDR_ANY;

    int err = bind(lsock, (struct sockaddr*) &saddr, sizeof(saddr));
    CHK_ERR(err, "ERROR cannot bind socket");

    err = listen(lsock, 5); // why 5 and not 2 ?
    CHK_ERR(err, "starting listening socket");

    ev_io_init(&w_accept, accept_cb, lsock, EV_READ);
    ev_io_start(loop, &w_accept);
    while(1) {
        ev_loop(loop, 0);
    }
    return 0;
}
/* accept client */
void accept_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
    struct sockaddr_in caddr;
    socklen_t caddr_len;
    int csock;
    struct ev_io *w_client = malloc(sizeof(struct ev_io));
    char caddr_s[INET_ADDRSTRLEN]; // string for ip_addr
    puts("accept_cb");

    if(EV_ERROR & revents) { perror("got invalid event"); return; }

    /* accept client req */
    csock = accept(watcher->fd, (struct sockaddr*) &caddr, &caddr_len);
    if(csock == 0)  { perror("ERROR on accepting new socket"); return; }

    inet_ntop(AF_INET, &(caddr.sin_addr), caddr_s, INET_ADDRSTRLEN);
    printf("Connection from %s : %d\n",
           caddr_s, ntohs(caddr.sin_port));

    // init new watcher to read client requests
    ev_io_init(w_client, read_cb, csock, EV_READ);
    ev_io_start(loop, w_client);
}


#define BUF_SIZE 128
void read_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
    char buffer[BUF_SIZE];
    ssize_t read;
    puts("read_cb");

    if(EV_ERROR & revents) {
        perror("got invalid event");
        return;
    }

    read = recv(watcher->fd, buffer, BUF_SIZE, 0);
    if(read < 0) { perror("ERROR on read"); return; }

    if(read != 0) {
        send(watcher->fd, buffer, read, 0);
        printf("message:%s\n", buffer);
        memset(buffer, 0, read);
    }

    ev_io_stop(loop, watcher);
    free(watcher);
    perror("closing peer");
}