title: How to connect a libwebsockets C client to a wsrelay server (node.js)
body: <p>On my mac, I installed and run <a href="https://www.npmjs.com/package/wsrelay" rel="nofollow">wsrelay</a></p>
  
  <pre><code>$ wsrelay
  listening on port 8124...
  </code></pre>
  
  <p>On my Ubuntu 14.04, I compiled and run a simple <code>libwebsockets</code> client connecting to the <strong>wsrelay</strong></p>
  
  <pre><code>#include &lt;stdio.h&gt;
  #include &lt;stdlib.h&gt;
  #include &lt;string.h&gt;
  #include &lt;unistd.h&gt;
  #include &lt;signal.h&gt;
  #include &lt;libwebsockets.h&gt;
  
  #define KGRN "\033[0;32;32m"
  #define KCYN "\033[0;36m"
  #define KRED "\033[0;32;31m"
  #define KYEL "\033[1;33m"
  #define KBLU "\033[0;32;34m"
  #define KCYN_L "\033[1;36m"
  #define KBRN "\033[0;33m"
  #define RESET "\033[0m"
  
  static int destroy_flag = 0;
  static int connection_flag = 0;
  static int writeable_flag = 0;
  
  static void INT_HANDLER(int signo) {
      destroy_flag = 1;
  }
  
  struct session_data {
      int fd;
  };
  
  static int websocket_write_back(struct lws *wsi_in, char *str, int str_size_in) 
  {
      if (str == NULL || wsi_in == NULL)
          return -1;
  
      int n;
      int len;
      char *out = NULL;
  
      if (str_size_in &lt; 1) 
          len = strlen(str);
      else
          len = str_size_in;
  
      out = (char *)malloc(sizeof(char)*(LWS_SEND_BUFFER_PRE_PADDING + len + LWS_SEND_BUFFER_POST_PADDING));
      //* setup the buffer*/
      memcpy (out + LWS_SEND_BUFFER_PRE_PADDING, str, len );
      //* write out*/
      n = lws_write(wsi_in, out + LWS_SEND_BUFFER_PRE_PADDING, len, LWS_WRITE_TEXT);
  
      printf(KBLU"[websocket_write_back] %s\n"RESET, str);
      //* free the buffer*/
      free(out);
  
      return n;
  }
  
  
  static int ws_service_callback(
                           struct lws *wsi,
                           enum lws_callback_reasons reason, void *user,
                           void *in, size_t len)
  {
  
      switch (reason) {
  
          case LWS_CALLBACK_CLIENT_ESTABLISHED:
              printf(KYEL"[Main Service] Connect with server success.\n"RESET);
              connection_flag = 1;
              websocket_write_back(wsi, "CLT - Client connected to server!", -1);
              break;
  
          case LWS_CALLBACK_CLIENT_CONNECTION_ERROR:
              printf(KRED"[Main Service] Connect with server error.\n"RESET);
              destroy_flag = 1;
              connection_flag = 0;
              break;
  
          case LWS_CALLBACK_CLOSED:
              printf(KYEL"[Main Service] LWS_CALLBACK_CLOSED\n"RESET);
              destroy_flag = 1;
              connection_flag = 0;
              break;
  
          case LWS_CALLBACK_CLIENT_RECEIVE:
              printf(KCYN_L"[Main Service] Client received:%s\n"RESET, (char *)in);
  
              break;
          case LWS_CALLBACK_CLIENT_WRITEABLE :
              printf(KYEL"[Main Service] On writeable is called. send byebye message\n"RESET);
              websocket_write_back(wsi, "Byebye! See you later", -1);
              writeable_flag = 1;
              break;
  
          default:
              break;
      }
  
      return 0;
  }
  
  
  int main(void)
  {
      //* register the signal SIGINT handler */
      struct sigaction act;
      act.sa_handler = INT_HANDLER;
      act.sa_flags = 0;
      sigemptyset(&amp;act.sa_mask);
      sigaction( SIGINT, &amp;act, 0);
  
      struct lws_context *context = NULL;
      struct lws_context_creation_info info;
      struct lws *wsi = NULL;
      struct lws_protocols protocol;
  
      memset(&amp;info, 0, sizeof info);
      info.port = CONTEXT_PORT_NO_LISTEN;
      info.iface = NULL;
      info.protocols = &amp;protocol;
      info.ssl_cert_filepath = NULL;
      info.ssl_private_key_filepath = NULL;
      info.extensions = lws_get_internal_extensions();
      info.gid = -1;
      info.uid = -1;
      info.options = 0;
  
      protocol.name  = "my-echo-protocol";
      protocol.callback = &amp;ws_service_callback;
      protocol.per_session_data_size = sizeof(struct session_data);
      protocol.rx_buffer_size = 0;
      protocol.id = 0;
      protocol.user = NULL;
  
      context = lws_create_context(&amp;info);
      printf(KRED"[Main] context created.\n"RESET);
  
      if (context == NULL) {
          printf(KRED"[Main] context is NULL.\n"RESET);
          return -1;
      }
  
      wsi = lws_client_connect(context, "Mac-IP-address", 8124, 0,
              "/", "Mac-IP-address:8124", NULL,
               protocol.name, -1);
      if (wsi == NULL) {
          printf(KRED"[Main] wsi create error.\n"RESET);
          return -1;
      }
  
      printf(KGRN"[Main] wsi create success.\n"RESET);
  
      while(!destroy_flag)
      {
          lws_service(context, 50);
      }
  
      lws_context_destroy(context);
  
      return 0;
  }
  </code></pre>
  
  <p>but when I run the client, the message sent to the server using <code>websocket_write_back</code> never reaches the server although the connection seems to have established properly. I am guessing this is something about the protocol?? Any pointers about what I may be doing wrong? </p>
  
  <pre><code>$ ./example-client 
  [1452543414:0970] NOTICE: Initial logging level 7
  [1452543414:0971] NOTICE: Libwebsockets version: 1.6.0 0c7e5a9
  [1452543414:0971] NOTICE: IPV6 not compiled in
  [1452543414:0971] NOTICE: libev support not compiled in
  [1452543414:0972] NOTICE:  mem: platform fd map:  8192 bytes
  [1452543414:0972] NOTICE:  mem: per-conn:          352 bytes + protocol rx buf
  [1452543414:0972] NOTICE:  canonical_hostname = linux-Lenovo-G50-70
  [Main] context created.
  [Main] wsi create success.
  [Main Service] Connect with server success.
  [websocket_write_back] CLT - Client connected to server!
  </code></pre>