WebSocket with CONNECT_ONLY

This example sets up a WebSocket stream with libcurl, then does the rest of the communication using curl_ws_recv() and curl_ws_send().

If your WebSocket is more transfer-oriented rather than a back-and-forth, it might be easier to do it with callbacks.

#include <string.h>
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#define sleep(s) Sleep((DWORD)(s * 1000))
#else
#include <unistd.h>
#endif

#include <curl/curl.h>

static CURLcode ping(CURL *curl, const char *send_payload)
{
  CURLcode result = CURLE_OK;
  const char *buf = send_payload;
  size_t sent, blen = strlen(send_payload);

  while(blen) {
    result = curl_ws_send(curl, buf, blen, &sent, 0, CURLWS_PING);
    if(result == CURLE_OK) {
      buf += sent; /* deduct what was sent */
      blen -= sent;
    }
    else if(result == CURLE_AGAIN) { /* blocked on sending */
      fprintf(stderr, "ws: sent PING blocked, waiting a second\n");
      sleep(1); /* either select() on socket or max timeout would
                   be good here. */
    }
    else /* real error sending */
      break;
  }
  if(result == CURLE_OK)
    fprintf(stderr, "ws: sent PING with payload\n");
  return result;
}

static CURLcode recv_pong(CURL *curl, const char *expected_payload)
{
  size_t rlen = 0;
  const struct curl_ws_frame *meta;
  char buffer[256];
  CURLcode result;

retry:
  result = curl_ws_recv(curl, buffer, sizeof(buffer), &rlen, &meta);
  if(result == CURLE_OK) {
    /* on small PING content, this example assumes the complete
     * PONG content arrives in one go. Larger frames arrive
     * in chunks, however. */
    if(meta->flags & CURLWS_PONG) {
      int same = 0;
      if(rlen == strlen(expected_payload)) {
        if(!memcmp(expected_payload, buffer, rlen))
          same = 1;
      }
      fprintf(stderr, "ws: received PONG with %s payload back\n",
              same ? "same" : "different");
    }
    else if(meta->flags & CURLWS_TEXT) {
      fprintf(stderr, "ws: received TEXT frame '%.*s'\n",
              (int)rlen, buffer);
    }
    else if(meta->flags & CURLWS_BINARY) {
      fprintf(stderr, "ws: received BINARY frame of %u bytes\n",
              (unsigned int)rlen);
    }
    else {
      /* some other frame arrived. */
      fprintf(stderr, "ws: received frame of %u bytes rflags %x\n",
              (unsigned int)rlen, meta->flags);
      goto retry;
    }
  }
  else if(result == CURLE_AGAIN) { /* blocked on receiving */
    fprintf(stderr, "ws: PONG not there yet, waiting a second\n");
    sleep(1); /* either select() on socket or max timeout would
                 be good here. */
    goto retry;
  }
  if(result != CURLE_OK)
    fprintf(stderr, "ws: curl_ws_recv returned %u, received %u\n",
            (unsigned int)result, (unsigned int)rlen);
  return result;
}

/* close the connection */
static void websocket_close(CURL *curl)
{
  size_t sent;
  (void)curl_ws_send(curl, "", 0, &sent, 0, CURLWS_CLOSE);
}

static CURLcode websocket(CURL *curl)
{
  CURLcode result;
  int i = 0;
  do {
    result = ping(curl, "foobar");
    if(result != CURLE_OK)
      break;
    result = recv_pong(curl, "foobar");
    if(result != CURLE_OK)
      break;
    sleep(1);
  } while(i++ < 10);
  websocket_close(curl);
  return result;
}

int main(int argc, const char *argv[])
{
  CURL *curl;

  CURLcode result = curl_global_init(CURL_GLOBAL_ALL);
  if(result != CURLE_OK)
    return (int)result;

  curl = curl_easy_init();
  if(curl) {
    if(argc == 2)
      curl_easy_setopt(curl, CURLOPT_URL, argv[1]);
    else
      curl_easy_setopt(curl, CURLOPT_URL, "wss://example.com");

    curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 2L);

    /* Perform the request, result gets the return code */
    result = curl_easy_perform(curl);
    /* Check for errors */
    if(result != CURLE_OK)
      fprintf(stderr, "curl_easy_perform() failed: %s\n",
              curl_easy_strerror(result));
    else {
      /* connected and ready */
      result = websocket(curl);
    }

    /* always cleanup */
    curl_easy_cleanup(curl);
  }
  curl_global_cleanup();
  return (int)result;
}