static int channel_np_wait_until_connection_ready(noPollConn * conn, int timeout, int is_ssl) {
long int total_timeout = timeout;
int socket = nopoll_conn_socket(conn);
/* check if the connection already finished its connection
handshake */
do {
int rc;
#if defined(__linux__)
struct pollfd ufd;
memset(&ufd, 0, sizeof ufd);
ufd.fd = socket;
ufd.events = POLLIN;
rc = poll(&ufd, 1, 10 * 1000);
#else
struct timeval tv;
fd_set readfds;
fd_set writefds;
fd_set errorfds;
FD_ZERO(&readfds);
FD_ZERO(&writefds);
FD_ZERO(&errorfds);
FD_SET(socket, &readfds);
tv.tv_usec = 10 * 1000;
tv.tv_sec = 0;
/* Wait for some event to occur on file descriptor */
rc = select(socket + 1, &readfds, &writefds, &errorfds, &tv);
#endif
if (rc == -1) break;
/* For SSL connection, we need to call nopoll_conn_get_msg
* in order to handle SSL accept. One may expect this is
* done in nopoll_conn_is_ready()...
*/
if (is_ssl) nopoll_conn_get_msg (conn);
/* check if the connection is ok */
if (! nopoll_conn_is_ok (conn))
return nopoll_false;
/* reduce the amount of time we have to wait. This computation
* is not fully accurate but overall it is okay*/
total_timeout = total_timeout - 10;
} while (! nopoll_conn_is_ready (conn) && (total_timeout > 0));
/* report if the connection is ok */
return nopoll_conn_is_ready (conn);
}
/* following _wt_ functions are called from a worker thread so caution is required
* to keep its operations thread safe
*/
static int np_wt_accept (void * args) {
int rc;
ServerNP * si = (ServerNP *)args;
si->np_sock = nopoll_conn_accept (si->np_ctx, si->np_listener);
if (si->np_sock == NULL) {
/* nopoll library does not always set errno, in this case create
* a fake one.
*/
if (errno == 0) errno = EINVAL;
return -1;
}
(void) nopoll_conn_set_sock_block(nopoll_conn_socket(si->np_sock), nopoll_false);
rc = channel_np_wait_until_connection_ready(si->np_sock, 1000, si->is_ssl);
(void) nopoll_conn_set_sock_block(nopoll_conn_socket(si->np_sock), nopoll_true);
if (rc == 0) {
errno = EINVAL;
return -1;
}
assert (rc);
assert(nopoll_conn_is_ready(si->np_sock));
return (si->np_sock != NULL);
}
static int np_wt_connect(void * args) {
ChannelConnectInfo * info = (ChannelConnectInfo *)args;
noPollConn * conn;
if (info->is_ssl) {
noPollConnOpts * opts = NULL;
opts = nopoll_conn_opts_new ();
#ifdef _WRS_KERNEL
/* For VxWorks SSL peer certificate verification does not work; let's
* disable this for now.
*/
nopoll_conn_opts_ssl_peer_verify (opts, nopoll_false);
#endif
nopoll_conn_opts_set_ssl_protocol (opts, NOPOLL_METHOD_TLSV1_1);
conn = nopoll_conn_tls_new (info->np_ctx, opts, info->host, info->port, NULL, info->get_url, info->host_name, NULL);
} else {
conn = nopoll_conn_new (info->np_ctx, info->host, info->port, NULL, info->get_url, NULL, NULL);
}
if (! nopoll_conn_is_ok (conn)) {
nopoll_conn_close(conn);
errno = ECONNREFUSED;
return -1;
}
/* nopoll_conn_wait_until_connection_ready() can return true even if
* the connection is not ready but simply ok; no clue why. Let's check
* again that the connection is ready.
*/
if (! nopoll_conn_wait_until_connection_ready (conn, 10) || ! nopoll_conn_is_ready(conn)) {
nopoll_conn_close(conn);
errno = EPERM;
return -1;
}
assert (nopoll_conn_is_ready (conn));
assert (nopoll_conn_is_ok (conn));
/* Set the socket in blocking mode */
(void) nopoll_conn_set_sock_block(nopoll_conn_socket(conn), nopoll_true);
info->np_sock = conn;
return 0;
}
/**
* @brief Allows to create a new MQTT connection to a MQTT
* broker/server running MQTT over WebSocket.
*
* @param ctx The context where the operation will take place.
*
* @param client_identifier The client identifier that uniquely
* identifies this MQTT client from others. It can be NULL to let
* MQTT 3.1.1 servers to assign a default client identifier BUT
* clean_session must be set to axl_true. This is done automatically
* by the library (setting clean_session to axl_true when NULL is
* provided).
*
* @param clean_session Flag to clean client session or to reuse the
* existing one. If set to axl_false, you must provide a valid
* client_identifier (otherwise the function will fail).
*
* @param keep_alive Keep alive configuration in seconds after which
* the server/broker will close the connection if it doesn't detect
* any activity. Setting 0 will disable keep alive mechanism.
*
* @param conn A reference to an established noPollConn connection
* that is connecting to the MQTT over WebSocket server we want to
* connect to.
*
* @param opts Optional connection options. See \ref myqtt_conn_opts_new
*
* @param on_connected Async notification handler that will be called
* once the connection fails or it is completed. In the case this
* handler is configured the caller will not be blocked. In the case
* this parameter is NULL, the caller will be blocked until the
* connection completes or fails.
*
* @param user_data User defined pointer that will be passed to the on_connected handler (in case it is defined).
*
* @return A reference to the newli created connection or NULL if
* on_connected handler is provided. In both cases, the reference
* returned (or received at the on_connected handler) must be checked
* with \ref myqtt_conn_is_ok.
*
* <b>About pending messages / queued messages </b>
*
* After successful connection with clean_session set to axl_false and
* defined client identifier, the library will resend any queued or in
* flight QoS1/QoS2 messages (as well as QoS0 if they were
* stored). This is done in background without intefering the caller.
*
* If you need to get the number of queued messages that are going to
* be sent use \ref myqtt_storage_queued_messages_offline. In the case
* you need the number remaining during the process use \ref
* myqtt_storage_queued_messages.
*
* See \ref myqtt_conn_new for more information.
*
* <b>About reconnecting</b>
*
* If you enable automatic reconnect support after connection close
* (\ref myqtt_conn_opts_set_reconnect), remember to also configure
* the recover handler by using \ref myqtt_conn_opts_set_init_session_setup_ptr. That function should
* implement a complete reconnect and return a noPollConn reference
* used by the internal session setup. If you don't configure this,
* the function will disable reconnect support even if you enable it.
*
*/
MyQttConn * myqtt_web_socket_conn_new (MyQttCtx * ctx,
const char * client_identifier,
axl_bool clean_session,
int keep_alive,
noPollConn * conn,
MyQttConnOpts * opts,
MyQttConnNew on_connected,
axlPointer user_data)
{
/* check if the conn reference is not defined. In that case,
try to craete it with the init session setup ptr */
if (conn == NULL && opts && opts->init_session_setup_ptr)
conn = opts->init_session_setup_ptr (ctx, NULL, opts->init_user_data, opts->init_user_data2, opts->init_user_data3);
/* report what we are doing */
myqtt_log (MYQTT_LEVEL_DEBUG, "Creating new MQTT over WebSocket connection to %s:%s (is ready:%d, socket: %d)",
nopoll_conn_host (conn), nopoll_conn_port (conn), nopoll_conn_is_ready (conn), nopoll_conn_socket (conn));
/* check and disable reconnect if it is not configured the
recover handler */
if (opts && opts->reconnect) {
if (opts->init_session_setup_ptr == NULL) {
myqtt_log (MYQTT_LEVEL_CRITICAL, "Disable reconnect flag because user didn't provide a recover handler (myqtt_conn_opts_set_recover_session_setup_ptr)");
opts->reconnect = axl_false; /* disable it */
} /* end if */
} /* end opts */
/* associate context */
__myqtt_web_socket_associate_ctx (ctx, nopoll_conn_ctx (conn));
/* call to create the connection */
return myqtt_conn_new_full_common (ctx, client_identifier, clean_session, keep_alive,
/* destination host and port but only as a matter of reporting
because we are handling everything through the setup handler */
nopoll_conn_host (conn), nopoll_conn_port (conn),
/* this is the handler that will establish the connection on top
of the provided noPoll connection */
__myqtt_web_socket_session_setup, conn,
/* additional user handlers */
on_connected, -1, opts, user_data);
}
nopoll_bool test_sending_and_check_echo (noPollConn * conn, const char * label, const char * msg)
{
char buffer[1024];
int length = strlen (msg);
int bytes_read;
/* wait for the reply */
while (nopoll_true) {
if (nopoll_conn_is_ready (conn))
break;
nopoll_sleep (10000);
} /* end if */
/* send content text(utf-8) */
printf ("%s: sending content..\n", label);
if (nopoll_conn_send_text (conn, msg, length) != length) {
printf ("ERROR: Expected to find proper send operation..\n");
return nopoll_false;
}
/* wait for the reply (try to read 1024, blocking and with a 3 seconds timeout) */
bytes_read = nopoll_conn_read (conn, buffer, length, nopoll_true, 3000);
if (bytes_read > 0)
buffer[bytes_read] = 0;
if (bytes_read != length) {
printf ("ERROR: expected to find 14 bytes but found %d..\n", bytes_read);
return nopoll_false;
} /* end if */
/* check content received */
if (! nopoll_cmp (buffer, msg)) {
printf ("ERROR: expected to find message 'This is a test' but something different was received: '%s'..\n",
buffer);
return nopoll_false;
} /* end if */
printf ("%s: received reply and echo matches..\n", label);
/* return that we sent and received the echo reply */
return nopoll_true;
}
void* webSocketery()
{
noPollCtx *ctx = nopoll_ctx_new();
noPollMsg *msg;
noPollRole *role = nopoll_conn_role(NOPOLL_ROLE_UNKNOWN);
struct noPollHandshake *fetch;
noPollConnOpts *opts;
/* Comment the log lines to disable loging Debug Warnings and Critical errors (Better not)*/
//nopoll_log_color_enable(ctx, true);
//nopoll_log_enable(ctx, nopoll_true);
/* Initializing the cookie options */
opts = nopoll_conn_opts_new();
if (!ctx)
puts("error ctx is nill");
//To add Cookies use this method below
/* nopoll_conn_opts_set_cookie(opts, "BAYEUX_BROWSER=56a9-mchhnynonz6ji8a6hs1sh49; JSESSIONID=8gz8e00htqrl15vcm3o9yi95f"); */
// Websocketery Works for mtgox and others servers but not for m.zpush.ovh it keeps rejecting me for an unknown f*****g 400 error ! Use Methods below to connect to server, a working example is provided
//nopoll_conn_new(ctx, ip, port, host, get, protocols, origin) nopoll_conn_new_opts(ctx, opts, ip, port, host, get, protocols, origin)//
//noPollConn *conn = nopoll_conn_new(ctx , "54.171.156.38" ,"80" ,"m.zpush.ovh:8080" ,"ws://m.zpush.ovh:8080/str/strd" ,NULL, "Authorize");
noPollConn *conn = nopoll_conn_new(ctx, "54.238.149.121", "80", "websocket.mtgox.com", "/mtgox", NULL, "chat");
if (!nopoll_conn_wait_until_connection_ready(conn, 50) )
{ puts("nopoll_conn failed, timeout"); return (0);}
if (nopoll_conn_send_text (conn, "hello how are you doing, do we connect ?", 40) != 40)
{puts("send text just failed...."); return(0);}
else
{
while (! nopoll_conn_is_ready (conn)) {
if (! nopoll_conn_is_ok (conn)) {
printf ("ERROR (4.1 jkd412): expected to find proper connection handshake finished, but found connection is broken: session=%d, errno=%d : %s..\n",
(int) nopoll_conn_socket (conn), errno, strerror (errno));
return nopoll_false;
} /* end if */
/* wait a bit 10ms */
nopoll_sleep (10000);
} /* end if */
nopoll_conn_close (conn);
/* finish */
nopoll_ctx_unref (ctx);
puts("nopoll conn sucess");
while (nopoll_true)
{
if (nopoll_conn_is_ready(conn))
{
puts("break");
break;
}
nopoll_sleep(10000);
}
msg = nopoll_conn_get_msg(conn);
if (msg)
printf("Msg received = %s\n", nopoll_msg_get_payload(msg));
if (!nopoll_conn_is_ok(conn))
{
puts("------------ Connection Dead ----------------");
return nopoll_false;
}
}
nopoll_ctx_unref(ctx);
return (0);
}
