libev + non-blocking socket continuously invokes callback

I'm using libev + non-blocking sockets to send a request to a server. I'm using Keep Alive because I need to send future requests to the destination over this same connection.

Behavior Run the program and it fetches the URL and logs to console, as expected. After doing this, wait and don't push ctrl+c to exit the program.

Expected App should stay open because event loop is waiting for future responses but should not console log anything after the initial response.

Actual Leave the app running. After 30+ seconds, it will start to console log the same response over and over and over again without end.

Question Why is libev calling my callback (example_cb) repeatedly when no new request was sent and no new response data was received? How can I fix this?

#include <ev.h>
#include <stdio.h>
#include <iostream>
#include <ctype.h>
#include <cstring>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <unistd.h>
#include <sstream>
#include <fstream>
#include <string>

using namespace std;

void sendRequest(int sockfd)
{
  puts("------");
  puts("sendRequest() was called");
  stringstream ss;
  ss << "GET /posts/11 HTTP/1.1\r\n"
      << "Host: jsonplaceholder.typicode.com\r\n"
      << "Accept: application/json\r\n"
      << "\r\n";
  string request = ss.str();

  if (send(sockfd, request.c_str(), request.length(), 0) != (int)request.length()) {
    cout << "Error sending request." << endl;
    exit(1);
  }
  cout << "Request sent. No err occured." << endl;
}

static void delay_cb(EV_P_ ev_timer *w, int revents)
{
  puts("------");
  puts("delay_cb() was called");
  sendRequest(3);
}


static void example_cb(EV_P_ ev_io *w, int revents)
{
  puts("------");
  puts("example_cb() was called");
  int sockfd = 3;

  size_t len = 80*1024, nparsed; // response must be <= 80 Kb
  char buf[len];
  ssize_t recved;

  recved = recv(sockfd, &buf, len, 0);

  if (recved < 0) {
    perror("recved was <1");
  }

  // don't process keep alives
  if (buf[0] != '\0') {
    std::cout << buf << std::endl;
  }

  // clear buf
  buf[0] = '\0';
  std::cout << "buf after clear attempt: " << buf << std::endl;
}

int example_request()
{
  std::string hostname = "jsonplaceholder.typicode.com";
  int PORT = 80;

  struct sockaddr_in client;
  struct hostent * host = gethostbyname(hostname.c_str());
  if (host == NULL || host->h_addr == NULL) {
    cout << "Error retrieving DNS information." << endl;
    exit(1);
  }

  bzero(&client, sizeof(client));
  client.sin_family = AF_INET;
  client.sin_port = htons( PORT );
  memcpy(&client.sin_addr, host->h_addr, host->h_length);

  // create a socket
  int sockfd = socket(PF_INET, SOCK_STREAM, 0);
  if (sockfd < 0) {
    cout << "Error creating socket." << endl;
    exit(1);
  }
  cout << "Socket created" << endl;

  // enable keep alive
  int val = 1;
  setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &val, sizeof val);

  if (connect(sockfd, (struct sockaddr *)&client, sizeof(client)) < 0) {
    close(sockfd);
    cout << "Could not connect" << endl;
    exit(1);
  }
  cout << "Socket connected" << endl;

  // make non-blocking
  int status = fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFL, 0) | O_NONBLOCK);
  if (status == -1) {
    perror("ERROR making socket non-blocking");
  }
  std::cout << "Socket set to non-blocking" << std::endl;

  std::cout << "Sockfd is: " << sockfd << std::endl;
  return sockfd;
}

int main(void)
{
  // establish socket connection
  int sockfd = example_request();

  struct ev_loop *loop = EV_DEFAULT;

  ev_io example_watcher;
  ev_io_init(&example_watcher, example_cb, sockfd, EV_READ);
  ev_io_start(loop, &example_watcher);

  // used to send the request 2 sec later
  ev_timer delay_watcher;
  ev_timer_init(&delay_watcher, delay_cb, 2, 0.0);
  ev_timer_start(loop, &delay_watcher);

  ev_run(loop, 0);

  return 0;
}

Edit: Code updated with suggestions from comments

The source of the problem is that you do not check recved == 0 condition which corresponds to the other side closing the connection. When that happens the OS sets the socket into "closed mode" which (at least under linux) is always ready for reading and subsequent calls to recv will always return 0.

So what you need to do is to check for that condition, call close(fd); on the file descriptor (possibly with shutdown before) and ev_io_stop on the associated watcher. If you wish to continue at that point then you have to open a new socket and eo_io_start new watcher.