libcurl：连接保持活动如何工作？

Question

How do I keep connection alive with libcurl?

The usage that I'd like is the following. I want to connect to a server that supports Keep-Alive but which closes the connection after 90 seconds of inactivity. I want to do POST once in a while when some events (outside of this connection) occur, and I want to keep the connection alive in order to reduce latency. It might happen that no event occurs for more than 90 seconds, so I want a way to tell the server I'm not idle.

The examples page is excellent, but I don't see one involving Keep-Alive : https://curl.haxx.se/libcurl/c/example.html

I did find CURLOPT_TCP_KEEPINTVL : https://curl.haxx.se/libcurl/c/CURLOPT_TCP_KEEPINTVL.html , but it's not clear to me how it's supposed to work. In that example, we see the code:

CURL *curl = curl_easy_init();
if(curl) {
  curl_easy_setopt(curl, CURLOPT_URL, "http://example.com");

  /* enable TCP keep-alive for this transfer */
  curl_easy_setopt(curl, CURLOPT_TCP_KEEPALIVE, 1L);

  /* set keep-alive idle time to 120 seconds */
  curl_easy_setopt(curl, CURLOPT_TCP_KEEPIDLE, 120L);

  /* interval time between keep-alive probes: 60 seconds */
  curl_easy_setopt(curl, CURLOPT_TCP_KEEPINTVL, 60L);

  curl_easy_perform(curl);
}

The description says the following:

Pass a long. Sets the interval, in seconds, that the operating system will wait between sending keepalive probes. Not all operating systems support this option. (Added in 7.25.0)

Two questions:

A) Operationally, how do I use this? From the description, it looks like as long as I keep curl in scope, the connection will remain open. Is this correct? And then should I just keep doing

curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postthis);
res = curl_easy_perform(curl);

whenever I want to POST more data and it will be sent in the same connection, or is there more to it?

B) What are these keepalive probes and where can I read more about them? Is this something that the OS does behind my back? Should I think of this as: from the point of view of my application, the connection is magically alive and I shouldn't worry about it?

---

Yes, I meant HTTP Keep-Alive , sorry for the ambiguity.

Since yesterday, I found that Daniel Stenberg himself has answered a similar question here: https://stackoverflow.com/a/14148171/12874900

This answers part A) of my question. But it doesn't answer question B). I would also need to know: if the connection does die for whatever reason, how am I meant to detect it? Or does libcurl take care of the reconnect?

Someone feel free to edit this into my original post.

Answer 1

HTTP persistent connections

As said many times: libcurl does persistent HTTP connections by default. You just have to reuse the curl handles for that to work and you have to actively ask for not doing them persistent if you don't want them. It doesn't matter what HTTP method you use. GET, POST, HEAD etc all maintain the connection - unless something out of the ordinary happens.

Modern libcurl versions will however only reuse connections up CURLOPT_MAXAGE_CONN seconds (118 by default) - since the chance of successful reuse diminishes really quickly over time.

Sometimes you see clients use the Keep-Alive: header but that's legacy from the HTTP/1.0 days and is virtually pointless in this day and age.

If the connection closes after 90 seconds as claimed in this question, that is because the server closes idle connections then. Servers do that. You can't prevent them in any other way than to use the connection again before the server kills it.

TCP Keepalive

The TCP keepalive options are at an entirely different level. That's basically TCP sending a packet over the connection after N seconds of inactivity, in order to make sure the connection is kept alive (and to detect broken connections).

libcurl does not enable TCP keepalive by default, see CURLOPT_TCP_KEEPALIVE .