ext/paho.mqtt.c/src/samples/paho_c_pub.c - a71ch-crypto-support - Git at Google

 /*******************************************************************************
  * Copyright (c) 2012, 2020 IBM Corp., and others
  *
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v2.0
  * and Eclipse Distribution License v1.0 which accompany this distribution.
  *
  * The Eclipse Public License is available at
  *   https://www.eclipse.org/legal/epl-2.0/
  * and the Eclipse Distribution License is available at
  *   http://www.eclipse.org/org/documents/edl-v10.php.
  *
  * Contributors:
  *    Ian Craggs - initial contribution
  *    Guilherme Maciel Ferreira - add keep alive option
  *    Ian Craggs - add full capability
  *******************************************************************************/

 #include "MQTTAsync.h"
 #include "pubsub_opts.h"

 #include <stdio.h>
 #include <signal.h>
 #include <string.h>
 #include <stdlib.h>

 #if defined(_WIN32)
 #include <windows.h>
 #define sleep Sleep
 #else
 #include <unistd.h>
 #include <sys/time.h>
 #include <unistd.h>
 #endif

 #if defined(_WRS_KERNEL)
 #include <OsWrapper.h>
 #endif

 volatile int toStop = 0;

 struct pubsub_opts opts =
 {
 	1, 0, 0, 0, "\n", 100,  	/* debug/app options */
 	NULL, NULL, 1, 0, 0, /* message options */
 	MQTTVERSION_DEFAULT, NULL, "paho-c-pub", 0, 0, NULL, NULL, "localhost", "1883", NULL, 10, /* MQTT options */
 	NULL, NULL, 0, 0, /* will options */
 	0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* TLS options */
 	0, {NULL, NULL}, /* MQTT V5 options */
 };

 MQTTAsync_responseOptions pub_opts = MQTTAsync_responseOptions_initializer;
 MQTTProperty property;
 MQTTProperties props = MQTTProperties_initializer;


 void mysleep(int ms)
 {
 	#if defined(_WIN32)
 		Sleep(ms);
 	#else
 		usleep(ms * 1000);
 	#endif
 }

 void cfinish(int sig)
 {
 	signal(SIGINT, NULL);
 	toStop = 1;
 }


 int messageArrived(void* context, char* topicName, int topicLen, MQTTAsync_message* m)
 {
 	/* not expecting any messages */
 	return 1;
 }


 static int disconnected = 0;

 void onDisconnect5(void* context, MQTTAsync_successData5* response)
 {
 	disconnected = 1;
 }

 void onDisconnect(void* context, MQTTAsync_successData* response)
 {
 	disconnected = 1;
 }


 static int connected = 0;
 void myconnect(MQTTAsync client);
 int mypublish(MQTTAsync client, int datalen, char* data);

 void onConnectFailure5(void* context, MQTTAsync_failureData5* response)
 {
 	fprintf(stderr, "Connect failed, rc %s reason code %s\n",
 		MQTTAsync_strerror(response->code),
 		MQTTReasonCode_toString(response->reasonCode));
 	connected = -1;

 	MQTTAsync client = (MQTTAsync)context;
 }

 void onConnectFailure(void* context, MQTTAsync_failureData* response)
 {
 	fprintf(stderr, "Connect failed, rc %s\n", response ? MQTTAsync_strerror(response->code) : "none");
 	connected = -1;

 	MQTTAsync client = (MQTTAsync)context;
 }


 void onConnect5(void* context, MQTTAsync_successData5* response)
 {
 	MQTTAsync client = (MQTTAsync)context;
 	int rc = 0;

 	if (opts.verbose)
 		printf("Connected\n");

 	if (opts.null_message == 1)
 		rc = mypublish(client, 0, "");
 	else if (opts.message)
 		rc = mypublish(client, (int)strlen(opts.message), opts.message);
 	else if (opts.filename)
 	{
 		int data_len = 0;
 		char* buffer = readfile(&data_len, &opts);

 		if (buffer == NULL)
 			toStop = 1;
 		else
 		{
 			rc = mypublish(client, data_len, buffer);
 			free(buffer);
 		}
 	}

 	connected = 1;
 }

 void onConnect(void* context, MQTTAsync_successData* response)
 {
 	MQTTAsync client = (MQTTAsync)context;
 	int rc = 0;

 	if (opts.verbose)
 		printf("Connected\n");

 	if (opts.null_message == 1)
 		rc = mypublish(client, 0, "");
 	else if (opts.message)
 		rc = mypublish(client, (int)strlen(opts.message), opts.message);
 	else if (opts.filename)
 	{
 		int data_len = 0;
 		char* buffer = readfile(&data_len, &opts);

 		if (buffer == NULL)
 			toStop = 1;
 		else
 		{
 			rc = mypublish(client, data_len, buffer);
 			free(buffer);
 		}
 	}

 	connected = 1;
 }


 static int published = 0;

 void onPublishFailure5(void* context, MQTTAsync_failureData5* response)
 {
 	if (opts.verbose)
 		fprintf(stderr, "Publish failed, rc %s reason code %s\n",
 				MQTTAsync_strerror(response->code),
 				MQTTReasonCode_toString(response->reasonCode));
 	published = -1;
 }

 void onPublishFailure(void* context, MQTTAsync_failureData* response)
 {
 	if (opts.verbose)
 		fprintf(stderr, "Publish failed, rc %s\n", MQTTAsync_strerror(response->code));
 	published = -1;
 }


 void onPublish5(void* context, MQTTAsync_successData5* response)
 {
 	if (opts.verbose)
 		printf("Publish succeeded, reason code %s\n",
 				MQTTReasonCode_toString(response->reasonCode));

 	if (opts.null_message || opts.message || opts.filename)
 		toStop = 1;

 	published = 1;
 }


 void onPublish(void* context, MQTTAsync_successData* response)
 {
 	if (opts.verbose)
 		printf("Publish succeeded\n");

 	if (opts.null_message || opts.message || opts.filename)
 		toStop = 1;

 	published = 1;
 }


 static int onSSLError(const char *str, size_t len, void *context)
 {
 	MQTTAsync client = (MQTTAsync)context;
 	return fprintf(stderr, "SSL error: %s\n", str);
 }

 static unsigned int onPSKAuth(const char* hint,
                               char* identity,
                               unsigned int max_identity_len,
                               unsigned char* psk,
                               unsigned int max_psk_len,
                               void* context)
 {
 	int psk_len;
 	int k, n;

 	int rc = 0;
 	struct pubsub_opts* opts = context;

 	/* printf("Trying TLS-PSK auth with hint: %s\n", hint);*/

 	if (opts->psk == NULL || opts->psk_identity == NULL)
 	{
 		/* printf("No PSK entered\n"); */
 		goto exit;
 	}

 	/* psk should be array of bytes. This is a quick and dirty way to
 	 * convert hex to bytes without input validation */
 	psk_len = (int)strlen(opts->psk) / 2;
 	if (psk_len > max_psk_len)
 	{
 		fprintf(stderr, "PSK too long\n");
 		goto exit;
 	}
 	for (k=0, n=0; k < psk_len; k++, n += 2)
 	{
 		sscanf(&opts->psk[n], "%2hhx", &psk[k]);
 	}

 	/* identity should be NULL terminated string */
 	strncpy(identity, opts->psk_identity, max_identity_len);
 	if (identity[max_identity_len - 1] != '\0')
 	{
 		fprintf(stderr, "Identity too long\n");
 		goto exit;
 	}

 	/* Function should return length of psk on success. */
 	rc = psk_len;

 exit:
 	return rc;
 }

 void myconnect(MQTTAsync client)
 {
 	MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
 	MQTTAsync_SSLOptions ssl_opts = MQTTAsync_SSLOptions_initializer;
 	MQTTAsync_willOptions will_opts = MQTTAsync_willOptions_initializer;
 	int rc = 0;

 	if (opts.verbose)
 		printf("Connecting\n");
 	if (opts.MQTTVersion == MQTTVERSION_5)
 	{
 		MQTTAsync_connectOptions conn_opts5 = MQTTAsync_connectOptions_initializer5;
 		conn_opts = conn_opts5;
 		conn_opts.onSuccess5 = onConnect5;
 		conn_opts.onFailure5 = onConnectFailure5;
 		conn_opts.cleanstart = 1;
 	}
 	else
 	{
 		conn_opts.onSuccess = onConnect;
 		conn_opts.onFailure = onConnectFailure;
 		conn_opts.cleansession = 1;
 	}
 	conn_opts.keepAliveInterval = opts.keepalive;
 	conn_opts.username = opts.username;
 	conn_opts.password = opts.password;
 	conn_opts.MQTTVersion = opts.MQTTVersion;
 	conn_opts.context = client;
 	conn_opts.automaticReconnect = 1;

 	if (opts.will_topic) 	/* will options */
 	{
 		will_opts.message = opts.will_payload;
 		will_opts.topicName = opts.will_topic;
 		will_opts.qos = opts.will_qos;
 		will_opts.retained = opts.will_retain;
 		conn_opts.will = &will_opts;
 	}

 	if (opts.connection && (strncmp(opts.connection, "ssl://", 6) == 0 ||
 			strncmp(opts.connection, "wss://", 6) == 0))
 	{
 		if (opts.insecure)
 			ssl_opts.verify = 0;
 		else
 			ssl_opts.verify = 1;
 		ssl_opts.CApath = opts.capath;
 		ssl_opts.keyStore = opts.cert;
 		ssl_opts.trustStore = opts.cafile;
 		ssl_opts.privateKey = opts.key;
 		ssl_opts.privateKeyPassword = opts.keypass;
 		ssl_opts.enabledCipherSuites = opts.ciphers;
 		ssl_opts.ssl_error_cb = onSSLError;
 		ssl_opts.ssl_error_context = client;
 		ssl_opts.ssl_psk_cb = onPSKAuth;
 		ssl_opts.ssl_psk_context = &opts;
 		conn_opts.ssl = &ssl_opts;
 	}

 	connected = 0;
 	if ((rc = MQTTAsync_connect(client, &conn_opts)) != MQTTASYNC_SUCCESS)
 	{
 		fprintf(stderr, "Failed to start connect, return code %s\n", MQTTAsync_strerror(rc));
 		exit(EXIT_FAILURE);
 	}
 }


 int mypublish(MQTTAsync client, int datalen, char* data)
 {
 	int rc;

 	if (opts.verbose)
 		printf("Publishing data of length %d\n", datalen);

 	rc = MQTTAsync_send(client, opts.topic, datalen, data, opts.qos, opts.retained, &pub_opts);
 	if (opts.verbose && rc != MQTTASYNC_SUCCESS && !opts.quiet)
 		fprintf(stderr, "Error from MQTTAsync_send: %s\n", MQTTAsync_strerror(rc));

 	return rc;
 }


 void trace_callback(enum MQTTASYNC_TRACE_LEVELS level, char* message)
 {
 	fprintf(stderr, "Trace : %d, %s\n", level, message);
 }


 int main(int argc, char** argv)
 {
 	MQTTAsync_disconnectOptions disc_opts = MQTTAsync_disconnectOptions_initializer;
 	MQTTAsync_createOptions create_opts = MQTTAsync_createOptions_initializer;
 	MQTTAsync client;
 	char* buffer = NULL;
 	char* url = NULL;
 	int url_allocated = 0;
 	int rc = 0;
 	const char* version = NULL;
 	const char* program_name = "paho_c_pub";
 	MQTTAsync_nameValue* infos = MQTTAsync_getVersionInfo();
 #if !defined(_WIN32)
     struct sigaction sa;
 #endif

 	if (argc < 2)
 		usage(&opts, (pubsub_opts_nameValue*)infos, program_name);

 	if (getopts(argc, argv, &opts) != 0)
 		usage(&opts, (pubsub_opts_nameValue*)infos, program_name);

 	if (opts.connection)
 		url = opts.connection;
 	else
 	{
 		url = malloc(100);
 		url_allocated = 1;
 		sprintf(url, "%s:%s", opts.host, opts.port);
 	}
 	if (opts.verbose)
 		printf("URL is %s\n", url);

 	if (opts.tracelevel > 0)
 	{
 		MQTTAsync_setTraceCallback(trace_callback);
 		MQTTAsync_setTraceLevel(opts.tracelevel);
 	}

 	create_opts.sendWhileDisconnected = 1;
 	if (opts.MQTTVersion >= MQTTVERSION_5)
 		create_opts.MQTTVersion = MQTTVERSION_5;
 	rc = MQTTAsync_createWithOptions(&client, url, opts.clientid, MQTTCLIENT_PERSISTENCE_NONE, NULL, &create_opts);
 	if (rc != MQTTASYNC_SUCCESS)
 	{
 		if (!opts.quiet)
 			fprintf(stderr, "Failed to create client, return code: %s\n", MQTTAsync_strerror(rc));
 		exit(EXIT_FAILURE);
 	}

 #if defined(_WIN32)
 	signal(SIGINT, cfinish);
 	signal(SIGTERM, cfinish);
 #else
     memset(&sa, 0, sizeof(struct sigaction));
     sa.sa_handler = cfinish;
     sa.sa_flags = 0;

     sigaction(SIGINT, &sa, NULL);
     sigaction(SIGTERM, &sa, NULL);
 #endif

 	rc = MQTTAsync_setCallbacks(client, client, NULL, messageArrived, NULL);
 	if (rc != MQTTASYNC_SUCCESS)
 	{
 		if (!opts.quiet)
 			fprintf(stderr, "Failed to set callbacks, return code: %s\n", MQTTAsync_strerror(rc));
 		exit(EXIT_FAILURE);
 	}

 	if (opts.MQTTVersion >= MQTTVERSION_5)
 	{
 		pub_opts.onSuccess5 = onPublish5;
 		pub_opts.onFailure5 = onPublishFailure5;

 		if (opts.message_expiry > 0)
 		{
 			property.identifier = MQTTPROPERTY_CODE_MESSAGE_EXPIRY_INTERVAL;
 			property.value.integer4 = opts.message_expiry;
 			MQTTProperties_add(&props, &property);
 		}
 		if (opts.user_property.name)
 		{
 			property.identifier = MQTTPROPERTY_CODE_USER_PROPERTY;
 			property.value.data.data = opts.user_property.name;
 			property.value.data.len = (int)strlen(opts.user_property.name);
 			property.value.value.data = opts.user_property.value;
 			property.value.value.len = (int)strlen(opts.user_property.value);
 			MQTTProperties_add(&props, &property);
 		}
 		pub_opts.properties = props;
 	}
 	else
 	{
 		pub_opts.onSuccess = onPublish;
 		pub_opts.onFailure = onPublishFailure;
 	}

 	myconnect(client);

 	while (!toStop)
 	{
 		int data_len = 0;
 		int delim_len = 0;

 		if (opts.stdin_lines)
 		{
 			buffer = malloc(opts.maxdatalen);

 			delim_len = (int)strlen(opts.delimiter);
 			do
 			{
 				buffer[data_len++] = getchar();
 				if (data_len > delim_len)
 				{
 					if (strncmp(opts.delimiter, &buffer[data_len - delim_len], delim_len) == 0)
 						break;
 				}
 			} while (data_len < opts.maxdatalen);

 			rc = mypublish(client, data_len, buffer);
 		}
 		else
 			mysleep(100);
 	}

 	if (opts.message == 0 && opts.null_message == 0 && opts.filename == 0)
 		free(buffer);

 	if (opts.MQTTVersion >= MQTTVERSION_5)
 		disc_opts.onSuccess5 = onDisconnect5;
 	else
 		disc_opts.onSuccess = onDisconnect;
 	if ((rc = MQTTAsync_disconnect(client, &disc_opts)) != MQTTASYNC_SUCCESS)
 	{
 		if (!opts.quiet)
 			fprintf(stderr, "Failed to start disconnect, return code: %s\n", MQTTAsync_strerror(rc));
 		exit(EXIT_FAILURE);
 	}

 	while (!disconnected)
 		mysleep(100);

 	MQTTAsync_destroy(&client);

 	if (url_allocated)
 		free(url);

 	return EXIT_SUCCESS;
 }
	/*******************************************************************************
	* Copyright (c) 2012, 2020 IBM Corp., and others
	*
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v2.0
	* and Eclipse Distribution License v1.0 which accompany this distribution.
	*
	* The Eclipse Public License is available at
	* https://www.eclipse.org/legal/epl-2.0/
	* and the Eclipse Distribution License is available at
	* http://www.eclipse.org/org/documents/edl-v10.php.
	*
	* Contributors:
	* Ian Craggs - initial contribution
	* Guilherme Maciel Ferreira - add keep alive option
	* Ian Craggs - add full capability
	*******************************************************************************/

	#include "MQTTAsync.h"
	#include "pubsub_opts.h"

	#include <stdio.h>
	#include <signal.h>
	#include <string.h>
	#include <stdlib.h>

	#if defined(_WIN32)
	#include <windows.h>
	#define sleep Sleep
	#else
	#include <unistd.h>
	#include <sys/time.h>
	#include <unistd.h>
	#endif

	#if defined(_WRS_KERNEL)
	#include <OsWrapper.h>
	#endif

	volatile int toStop = 0;

	struct pubsub_opts opts =
	{
	1, 0, 0, 0, "\n", 100, /* debug/app options */
	NULL, NULL, 1, 0, 0, /* message options */
	MQTTVERSION_DEFAULT, NULL, "paho-c-pub", 0, 0, NULL, NULL, "localhost", "1883", NULL, 10, /* MQTT options */
	NULL, NULL, 0, 0, /* will options */
	0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* TLS options */
	0, {NULL, NULL}, /* MQTT V5 options */
	};

	MQTTAsync_responseOptions pub_opts = MQTTAsync_responseOptions_initializer;
	MQTTProperty property;
	MQTTProperties props = MQTTProperties_initializer;


	void mysleep(int ms)
	{
	#if defined(_WIN32)
	Sleep(ms);
	#else
	usleep(ms * 1000);
	#endif
	}

	void cfinish(int sig)
	{
	signal(SIGINT, NULL);
	toStop = 1;
	}


	int messageArrived(void* context, char* topicName, int topicLen, MQTTAsync_message* m)
	{
	/* not expecting any messages */
	return 1;
	}


	static int disconnected = 0;

	void onDisconnect5(void* context, MQTTAsync_successData5* response)
	{
	disconnected = 1;
	}

	void onDisconnect(void* context, MQTTAsync_successData* response)
	{
	disconnected = 1;
	}


	static int connected = 0;
	void myconnect(MQTTAsync client);
	int mypublish(MQTTAsync client, int datalen, char* data);

	void onConnectFailure5(void* context, MQTTAsync_failureData5* response)
	{
	fprintf(stderr, "Connect failed, rc %s reason code %s\n",
	MQTTAsync_strerror(response->code),
	MQTTReasonCode_toString(response->reasonCode));
	connected = -1;

	MQTTAsync client = (MQTTAsync)context;
	}

	void onConnectFailure(void* context, MQTTAsync_failureData* response)
	{
	fprintf(stderr, "Connect failed, rc %s\n", response ? MQTTAsync_strerror(response->code) : "none");
	connected = -1;

	MQTTAsync client = (MQTTAsync)context;
	}


	void onConnect5(void* context, MQTTAsync_successData5* response)
	{
	MQTTAsync client = (MQTTAsync)context;
	int rc = 0;

	if (opts.verbose)
	printf("Connected\n");

	if (opts.null_message == 1)
	rc = mypublish(client, 0, "");
	else if (opts.message)
	rc = mypublish(client, (int)strlen(opts.message), opts.message);
	else if (opts.filename)
	{
	int data_len = 0;
	char* buffer = readfile(&data_len, &opts);

	if (buffer == NULL)
	toStop = 1;
	else
	{
	rc = mypublish(client, data_len, buffer);
	free(buffer);
	}
	}

	connected = 1;
	}

	void onConnect(void* context, MQTTAsync_successData* response)
	{
	MQTTAsync client = (MQTTAsync)context;
	int rc = 0;

	if (opts.verbose)
	printf("Connected\n");

	if (opts.null_message == 1)
	rc = mypublish(client, 0, "");
	else if (opts.message)
	rc = mypublish(client, (int)strlen(opts.message), opts.message);
	else if (opts.filename)
	{
	int data_len = 0;
	char* buffer = readfile(&data_len, &opts);

	if (buffer == NULL)
	toStop = 1;
	else
	{
	rc = mypublish(client, data_len, buffer);
	free(buffer);
	}
	}

	connected = 1;
	}


	static int published = 0;

	void onPublishFailure5(void* context, MQTTAsync_failureData5* response)
	{
	if (opts.verbose)
	fprintf(stderr, "Publish failed, rc %s reason code %s\n",
	MQTTAsync_strerror(response->code),
	MQTTReasonCode_toString(response->reasonCode));
	published = -1;
	}

	void onPublishFailure(void* context, MQTTAsync_failureData* response)
	{
	if (opts.verbose)
	fprintf(stderr, "Publish failed, rc %s\n", MQTTAsync_strerror(response->code));
	published = -1;
	}


	void onPublish5(void* context, MQTTAsync_successData5* response)
	{
	if (opts.verbose)
	printf("Publish succeeded, reason code %s\n",
	MQTTReasonCode_toString(response->reasonCode));

	if (opts.null_message \|\| opts.message \|\| opts.filename)
	toStop = 1;

	published = 1;
	}


	void onPublish(void* context, MQTTAsync_successData* response)
	{
	if (opts.verbose)
	printf("Publish succeeded\n");

	if (opts.null_message \|\| opts.message \|\| opts.filename)
	toStop = 1;

	published = 1;
	}


	static int onSSLError(const char str, size_t len, void context)
	{
	MQTTAsync client = (MQTTAsync)context;
	return fprintf(stderr, "SSL error: %s\n", str);
	}

	static unsigned int onPSKAuth(const char* hint,
	char* identity,
	unsigned int max_identity_len,
	unsigned char* psk,
	unsigned int max_psk_len,
	void* context)
	{
	int psk_len;
	int k, n;

	int rc = 0;
	struct pubsub_opts* opts = context;

	/* printf("Trying TLS-PSK auth with hint: %s\n", hint);*/

	if (opts->psk == NULL \|\| opts->psk_identity == NULL)
	{
	/* printf("No PSK entered\n"); */
	goto exit;
	}

	/* psk should be array of bytes. This is a quick and dirty way to
	* convert hex to bytes without input validation */
	psk_len = (int)strlen(opts->psk) / 2;
	if (psk_len > max_psk_len)
	{
	fprintf(stderr, "PSK too long\n");
	goto exit;
	}
	for (k=0, n=0; k < psk_len; k++, n += 2)
	{
	sscanf(&opts->psk[n], "%2hhx", &psk[k]);
	}

	/* identity should be NULL terminated string */
	strncpy(identity, opts->psk_identity, max_identity_len);
	if (identity[max_identity_len - 1] != '\0')
	{
	fprintf(stderr, "Identity too long\n");
	goto exit;
	}

	/* Function should return length of psk on success. */
	rc = psk_len;

	exit:
	return rc;
	}

	void myconnect(MQTTAsync client)
	{
	MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
	MQTTAsync_SSLOptions ssl_opts = MQTTAsync_SSLOptions_initializer;
	MQTTAsync_willOptions will_opts = MQTTAsync_willOptions_initializer;
	int rc = 0;

	if (opts.verbose)
	printf("Connecting\n");
	if (opts.MQTTVersion == MQTTVERSION_5)
	{
	MQTTAsync_connectOptions conn_opts5 = MQTTAsync_connectOptions_initializer5;
	conn_opts = conn_opts5;
	conn_opts.onSuccess5 = onConnect5;
	conn_opts.onFailure5 = onConnectFailure5;
	conn_opts.cleanstart = 1;
	}
	else
	{
	conn_opts.onSuccess = onConnect;
	conn_opts.onFailure = onConnectFailure;
	conn_opts.cleansession = 1;
	}
	conn_opts.keepAliveInterval = opts.keepalive;
	conn_opts.username = opts.username;
	conn_opts.password = opts.password;
	conn_opts.MQTTVersion = opts.MQTTVersion;
	conn_opts.context = client;
	conn_opts.automaticReconnect = 1;

	if (opts.will_topic) /* will options */
	{
	will_opts.message = opts.will_payload;
	will_opts.topicName = opts.will_topic;
	will_opts.qos = opts.will_qos;
	will_opts.retained = opts.will_retain;
	conn_opts.will = &will_opts;
	}

	if (opts.connection && (strncmp(opts.connection, "ssl://", 6) == 0 \|\|
	strncmp(opts.connection, "wss://", 6) == 0))
	{
	if (opts.insecure)
	ssl_opts.verify = 0;
	else
	ssl_opts.verify = 1;
	ssl_opts.CApath = opts.capath;
	ssl_opts.keyStore = opts.cert;
	ssl_opts.trustStore = opts.cafile;
	ssl_opts.privateKey = opts.key;
	ssl_opts.privateKeyPassword = opts.keypass;
	ssl_opts.enabledCipherSuites = opts.ciphers;
	ssl_opts.ssl_error_cb = onSSLError;
	ssl_opts.ssl_error_context = client;
	ssl_opts.ssl_psk_cb = onPSKAuth;
	ssl_opts.ssl_psk_context = &opts;
	conn_opts.ssl = &ssl_opts;
	}

	connected = 0;
	if ((rc = MQTTAsync_connect(client, &conn_opts)) != MQTTASYNC_SUCCESS)
	{
	fprintf(stderr, "Failed to start connect, return code %s\n", MQTTAsync_strerror(rc));
	exit(EXIT_FAILURE);
	}
	}


	int mypublish(MQTTAsync client, int datalen, char* data)
	{
	int rc;

	if (opts.verbose)
	printf("Publishing data of length %d\n", datalen);

	rc = MQTTAsync_send(client, opts.topic, datalen, data, opts.qos, opts.retained, &pub_opts);
	if (opts.verbose && rc != MQTTASYNC_SUCCESS && !opts.quiet)
	fprintf(stderr, "Error from MQTTAsync_send: %s\n", MQTTAsync_strerror(rc));

	return rc;
	}


	void trace_callback(enum MQTTASYNC_TRACE_LEVELS level, char* message)
	{
	fprintf(stderr, "Trace : %d, %s\n", level, message);
	}


	int main(int argc, char** argv)
	{
	MQTTAsync_disconnectOptions disc_opts = MQTTAsync_disconnectOptions_initializer;
	MQTTAsync_createOptions create_opts = MQTTAsync_createOptions_initializer;
	MQTTAsync client;
	char* buffer = NULL;
	char* url = NULL;
	int url_allocated = 0;
	int rc = 0;
	const char* version = NULL;
	const char* program_name = "paho_c_pub";
	MQTTAsync_nameValue* infos = MQTTAsync_getVersionInfo();
	#if !defined(_WIN32)
	struct sigaction sa;
	#endif

	if (argc < 2)
	usage(&opts, (pubsub_opts_nameValue*)infos, program_name);

	if (getopts(argc, argv, &opts) != 0)
	usage(&opts, (pubsub_opts_nameValue*)infos, program_name);

	if (opts.connection)
	url = opts.connection;
	else
	{
	url = malloc(100);
	url_allocated = 1;
	sprintf(url, "%s:%s", opts.host, opts.port);
	}
	if (opts.verbose)
	printf("URL is %s\n", url);

	if (opts.tracelevel > 0)
	{
	MQTTAsync_setTraceCallback(trace_callback);
	MQTTAsync_setTraceLevel(opts.tracelevel);
	}

	create_opts.sendWhileDisconnected = 1;
	if (opts.MQTTVersion >= MQTTVERSION_5)
	create_opts.MQTTVersion = MQTTVERSION_5;
	rc = MQTTAsync_createWithOptions(&client, url, opts.clientid, MQTTCLIENT_PERSISTENCE_NONE, NULL, &create_opts);
	if (rc != MQTTASYNC_SUCCESS)
	{
	if (!opts.quiet)
	fprintf(stderr, "Failed to create client, return code: %s\n", MQTTAsync_strerror(rc));
	exit(EXIT_FAILURE);
	}

	#if defined(_WIN32)
	signal(SIGINT, cfinish);
	signal(SIGTERM, cfinish);
	#else
	memset(&sa, 0, sizeof(struct sigaction));
	sa.sa_handler = cfinish;
	sa.sa_flags = 0;

	sigaction(SIGINT, &sa, NULL);
	sigaction(SIGTERM, &sa, NULL);
	#endif

	rc = MQTTAsync_setCallbacks(client, client, NULL, messageArrived, NULL);
	if (rc != MQTTASYNC_SUCCESS)
	{
	if (!opts.quiet)
	fprintf(stderr, "Failed to set callbacks, return code: %s\n", MQTTAsync_strerror(rc));
	exit(EXIT_FAILURE);
	}

	if (opts.MQTTVersion >= MQTTVERSION_5)
	{
	pub_opts.onSuccess5 = onPublish5;
	pub_opts.onFailure5 = onPublishFailure5;

	if (opts.message_expiry > 0)
	{
	property.identifier = MQTTPROPERTY_CODE_MESSAGE_EXPIRY_INTERVAL;
	property.value.integer4 = opts.message_expiry;
	MQTTProperties_add(&props, &property);
	}
	if (opts.user_property.name)
	{
	property.identifier = MQTTPROPERTY_CODE_USER_PROPERTY;
	property.value.data.data = opts.user_property.name;
	property.value.data.len = (int)strlen(opts.user_property.name);
	property.value.value.data = opts.user_property.value;
	property.value.value.len = (int)strlen(opts.user_property.value);
	MQTTProperties_add(&props, &property);
	}
	pub_opts.properties = props;
	}
	else
	{
	pub_opts.onSuccess = onPublish;
	pub_opts.onFailure = onPublishFailure;
	}

	myconnect(client);

	while (!toStop)
	{
	int data_len = 0;
	int delim_len = 0;

	if (opts.stdin_lines)
	{
	buffer = malloc(opts.maxdatalen);

	delim_len = (int)strlen(opts.delimiter);
	do
	{
	buffer[data_len++] = getchar();
	if (data_len > delim_len)
	{
	if (strncmp(opts.delimiter, &buffer[data_len - delim_len], delim_len) == 0)
	break;
	}
	} while (data_len < opts.maxdatalen);

	rc = mypublish(client, data_len, buffer);
	}
	else
	mysleep(100);
	}

	if (opts.message == 0 && opts.null_message == 0 && opts.filename == 0)
	free(buffer);

	if (opts.MQTTVersion >= MQTTVERSION_5)
	disc_opts.onSuccess5 = onDisconnect5;
	else
	disc_opts.onSuccess = onDisconnect;
	if ((rc = MQTTAsync_disconnect(client, &disc_opts)) != MQTTASYNC_SUCCESS)
	{
	if (!opts.quiet)
	fprintf(stderr, "Failed to start disconnect, return code: %s\n", MQTTAsync_strerror(rc));
	exit(EXIT_FAILURE);
	}

	while (!disconnected)
	mysleep(100);

	MQTTAsync_destroy(&client);

	if (url_allocated)
	free(url);

	return EXIT_SUCCESS;
	}