Linux下MQTT客户端消息订阅与发布实现
MQTT(消息队列遥测传输)是一个基于客户端-服务器的消息发布/订阅传输协议。它基于TCP协议，默认端口号为1883，为此，它也需要一个消息中间件 。MQTT协议是轻量、简单、开放和易于实现的，这些特点使它适用范围非常广泛。在很多情况下，包括受限的环境中，如：机器与机器（M2M）通信和物联网（IoT），于此同时在智能家居、及一些小型化设备中也已广泛使用。
本文章简单介绍一下MQTT协议的具体应用实现，即客户端模式下消息的订阅与发布实现，运行环境为Linux系统，基于mosquitto这一份开源代码框架改装。具体操作步骤将在下面一一介绍。
首先下载一份开源的mosquitto代码，编译安装后将产生一系列可执行文件，常用的命令有mosquitto_sub,mosquitto_pub,mosquitto,分别为订阅客户端，发布客户端，以及服务器。
从mosquitto_sub对应的代码中拷贝一份出来，这里命名为mqtt_client.c，然后对其代码进行修改，整个内容如下：
/*
Copyright (c) 2009-2019 Roger Light
All rights reserved. This program and the accompanying materials
are made available under the terms of the Eclipse Public License v1.0
and Eclipse Distribution License v1.0 which accompany this distribution.
The Eclipse Public License is available at
http://www.eclipse.org/legal/epl-v10.html
and the Eclipse Distribution License is available at
http://www.eclipse.org/org/documents/edl-v10.php.
Contributors:
Roger Light - initial implementation and documentation.
*/
#include "config.h"
#include
#include
#include
#include
#include
#include
#ifndef WIN32
#include
#include
#else
#include
#include
#define snprintf sprintf_s
#endif
#include "mosquitto.h"
#include "mqtt_protocol.h"
#include "client_shared.h"
#include "pthread.h"
struct mosq_config cfg;
bool process_messages = true;
int msg_count = 0;
struct mosquitto *mosq = NULL;
int last_mid = 0;
#ifndef WIN32
void my_signal_handler(int signum)
{
if(signum == SIGALRM){
process_messages = false;
}
}
#endif
void print_message(struct mosq_config *cfg, const struct mosquitto_message *message);
/*
发布消息之后运行的回调函数
*/
void my_publish_callback(struct mosquitto *mosq, void *obj, int mid, int reason_code, const mosquitto_property *properties)
{
UNUSED(obj);
UNUSED(reason_code);
UNUSED(properties);
}
/*
订阅消息后触发的回调函数，可以在该函数处理接收到的消息，该回调函数必不可少。
*/
void my_message_callback(struct mosquitto *mosq, void *obj, const struct mosquitto_message *message, const mosquitto_property *properties)
{
struct mosq_config *cfg;
int i;
bool res;
assert(obj);
cfg = (struct mosq_config *)obj;
if(message->retain && cfg->no_retain) return;
//打印出订阅的主题以及消息长度
printf("[%s]topic:%s, payloadlen:%d", __func__, message->topic, message->payloadlen);
if(cfg->filter_outs)
{
for(i=0; ifilter_out_count; i++){
mosquitto_topic_matches_sub(cfg->filter_outs[i], message->topic, &res);
if(res) return;
}
}
if(cfg->verbose)
{
if(message->payloadlen)
{
fwrite("topic:", 1, strlen("topic:"), stdout);
printf("%s ", message->topic);
fwrite(message->payload, 1, message->payloadlen, stdout);
if(cfg->eol)
{
printf("\n");
}
}else{
if(cfg->eol){
printf("%s (null)\n", message->topic);
}
}
fflush(stdout);
}else{
if(message->payloadlen){
//打印接收到的消息
printf("[recv<==]%s\n", message->payload);
}
}
if(cfg->msg_count>0){
msg_count++;
if(cfg->msg_count == msg_count){
process_messages = false;
}
}
}
/*
连接MQTT服务器成功之后触发的回调函数，可在这个函数里面加入订阅主题的功能
*/
void my_connect_callback(struct mosquitto *mosq, void *obj, int result, int flags, const mosquitto_property *properties)
{
int i;
struct mosq_config *cfg;
assert(obj);
cfg = (struct mosq_config *)obj;
int svrchn;
if(!result)
{
for(i=0; itopic_count; i++)
{
//订阅主题的接口
mosquitto_subscribe(mosq, NULL, cfg->topics[i], cfg->qos);
}
}
}
/*
订阅主题成功之后触发的回调函数
*/
void my_subscribe_callback(struct mosquitto *mosq, void *obj, int mid, int qos_count, const int *granted_qos)
{
printf("subscribe_callback_v25");
int i;
struct mosq_config *cfg;
assert(obj);
cfg = (struct mosq_config *)obj;
if(!cfg->quiet) printf("Subscribed (mid: %d): %d\n", mid, granted_qos[0]);
for(i=1; iquiet) printf("%d\n", granted_qos[i]);
}
if(!cfg->quiet) printf("\n");
}
void my_log_callback(struct mosquitto *mosq, void *obj, int level, const char *str)
{
UNUSED(mosq);
UNUSED(obj);
UNUSED(level);
printf("%s\n", str);
}
/*
用于发布消息的回调函数，从缓存获取消息，并将该消息发布到服务端，该函数不可缺少。
*/
void mqtt_msg_publish_callback(struct mosquitto *mosq, void *obj, int mid)
{
char pubtopic[128]="test/topic";
if(msglen) {
printf("==>len:%d, topic:%s, msg:%s\n", msglen,pubtopic, msgbuf);
mosquitto_publish(mosq, NULL, pubtopic, msglen, msgbuf, 1, false);
msglen = 0;
}
}
/*
客户端help提示
*/
void print_usage(void)
{
int major, minor, revision;
mosquitto_lib_version(&major, &minor, &revision);
printf("mosquitto_sub is a simple mqtt client that will subscribe to a set of topics and print all messages it receives.\n");
printf("mosquitto_sub version %s running on libmosquitto %d.%d.%d.\n\n", "3.1.1", major, minor, revision);
printf("Usage: mosquitto_sub {[-h host] [-p port] [-u username] [-P password] -t topic | -L URL [-t topic]}\n");
printf(" [-c] [-k keepalive] [-q qos]\n");
printf(" [-C msg_count] [-E] [-R] [--retained-only] [--remove-retained] [-T filter_out] [-U topic ...]\n");
printf(" [-F format]\n");
#ifndef WIN32
printf(" [-W timeout_secs]\n");
#endif
#ifdef WITH_SRV
printf(" [-A bind_address] [-S]\n");
#else
printf(" [-A bind_address]\n");
#endif
printf(" [-i id] [-I id_prefix]\n");
printf(" [-d] [-N] [--quiet] [-v]\n");
printf(" [--will-topic [--will-payload payload] [--will-qos qos] [--will-retain]]\n");
#ifdef WITH_TLS
printf(" [{--cafile file | --capath dir} [--cert file] [--key file]\n");
printf(" [--ciphers ciphers] [--insecure]\n");
printf(" [--tls-alpn protocol]\n");
printf(" [--tls-engine engine] [--keyform keyform] [--tls-engine-kpass-sha1]]\n");
#ifdef FINAL_WITH_TLS_PSK
printf(" [--psk hex-key --psk-identity identity [--ciphers ciphers]]\n");
#endif
#endif
#ifdef WITH_SOCKS
printf(" [--proxy socks-url]\n");
#endif
printf(" [-D command identifier value]\n");
printf(" mosquitto_sub --help\n\n");
printf(" -A : bind the outgoing socket to this host/ip address. Use to control which interface\n");
printf(" the client communicates over.\n");
printf(" -c : disable 'clean session' (store subscription and pending messages when client disconnects).\n");
printf(" -C : disconnect and exit after receiving the 'msg_count' messages.\n");
printf(" -d : enable debug messages.\n");
printf(" -D : Define MQTT v5 properties. See the documentation for more details.\n");
printf(" -E : Exit once all subscriptions have been acknowledged by the broker.\n");
printf(" -F : output format.\n");
printf(" -h : mqtt host to connect to. Defaults to localhost.\n");
printf(" -i : id to use for this client. Defaults to mosquitto_sub_ appended with the process id.\n");
printf(" -I : define the client id as id_prefix appended with the process id. Useful for when the\n");
printf(" broker is using the clientid_prefixes option.\n");
printf(" -k : keep alive in seconds for this client. Defaults to 60.\n");
printf(" -L : specify user, password, hostname, port and topic as a URL in the form:\n");
printf(" mqtt(s)://[username[:password]@]host[:port]/topic\n");
printf(" -N : do not add an end of line character when printing the payload.\n");
printf(" -p : network port to connect to. Defaults to 1883 for plain MQTT and 8883 for MQTT over TLS.\n");
printf(" -P : provide a password\n");
printf(" -q : quality of service level to use for the subscription. Defaults to 0.\n");
printf(" -R : do not print stale messages (those with retain set).\n");
#ifdef WITH_SRV
printf(" -S : use SRV lookups to determine which host to connect to.\n");
#endif
printf(" -t : mqtt topic to subscribe to. May be repeated multiple times.\n");
printf(" -T : topic string to filter out of results. May be repeated.\n");
printf(" -u : provide a username\n");
printf(" -U : unsubscribe from a topic. May be repeated.\n");
printf(" -v : print published messages verbosely.\n");
printf(" -V : specify the version of the MQTT protocol to use when connecting.\n");
printf(" Can be mqttv5, mqttv311 or mqttv31. Defaults to mqttv311.\n");
#ifndef WIN32
printf(" -W : Specifies a timeout in seconds how long to process incoming MQTT messages.\n");
#endif
printf(" --help : display this message.\n");
printf(" --quiet : don't print error messages.\n");
printf(" --retained-only : only handle messages with the retained flag set, and exit when the\n");
printf(" first non-retained message is received.\n");
printf(" --remove-retained : send a message to the server to clear any received retained messages\n");
printf(" Use -T to filter out messages you do not want to be cleared.\n");
printf(" --will-payload : payload for the client Will, which is sent by the broker in case of\n");
printf(" unexpected disconnection. If not given and will-topic is set, a zero\n");
printf(" length message will be sent.\n");
printf(" --will-qos : QoS level for the client Will.\n");
printf(" --will-retain : if given, make the client Will retained.\n");
printf(" --will-topic : the topic on which to publish the client Will.\n");
#ifdef WITH_TLS
printf(" --cafile : path to a file containing trusted CA certificates to enable encrypted\n");
printf(" certificate based communication.\n");
printf(" --capath : path to a directory containing trusted CA certificates to enable encrypted\n");
printf(" communication.\n");
printf(" --cert : client certificate for authentication, if required by server.\n");
printf(" --key : client private key for authentication, if required by server.\n");
printf(" --keyform : keyfile type, can be either \"pem\" or \"engine\".\n");
printf(" --ciphers : openssl compatible list of TLS ciphers to support.\n");
printf(" --tls-version : TLS protocol version, can be one of tlsv1.3 tlsv1.2 or tlsv1.1.\n");
printf(" Defaults to tlsv1.2 if available.\n");
printf(" --insecure : do not check that the server certificate hostname matches the remote\n");
printf(" hostname. Using this option means that you cannot be sure that the\n");
printf(" remote host is the server you wish to connect to and so is insecure.\n");
printf(" Do not use this option in a production environment.\n");
printf(" --tls-engine : If set, enables the use of a SSL engine device.\n");
printf(" --tls-engine-kpass-sha1 : SHA1 of the key password to be used with the selected SSL engine.\n");
#ifdef FINAL_WITH_TLS_PSK
printf(" --psk : pre-shared-key in hexadecimal (no leading 0x) to enable TLS-PSK mode.\n");
printf(" --psk-identity : client identity string for TLS-PSK mode.\n");
#endif
#endif
#ifdef WITH_SOCKS
printf(" --proxy : SOCKS5 proxy URL of the form:\n");
printf(" socks5h://[username[:password]@]hostname[:port]\n");
printf(" Only \"none\" and \"username\" authentication is supported.\n");
#endif
printf("\nSee https://mosquitto.org/ for more information.\n\n");
}
/*
在这里定义消息缓存及消息长度
*/
char msgbuf[512];
int msglen;
/*
从终端接手输入的信息，并存入缓存
*/
void *mqtt_publish_hander(void *arg)
{
struct mosquitto *mosq = (struct mosquitto *)arg;
while(1) {
char pubtopic[128]="test/topic";
char testbuf[512]="";
printf("please input some thing:\n");
fgets(msgbuf, sizeof(msgbuf), stdin);
msglen = strlen(msgbuf);
}
}
/*
开启一个线程，用来处理输入的信息
*/
void mqtt_msg_publish_proc(struct mosquitto *mosq)
{
pthread_t TaskId;
pthread_attr_t att;
pthread_attr_init(&att);
pthread_attr_setdetachstate(&att, PTHREAD_CREATE_DETACHED);
int result = pthread_create(&TaskId, &att, mqtt_publish_hander, (void *)mosq);
}
/*
客户端程序入口函数
*/
int main(int argc, char *argv[])
{
int rc;
#ifndef WIN32
struct sigaction sigact;
#endif
mosquitto_lib_init();
rc = client_config_load(&cfg, CLIENT_SUB, argc, argv);
if(rc){
if(rc == 2){
/* --help */
print_usage();
}else{
fprintf(stderr, "\nUse 'mosquitto_sub --help' to see usage.\n");
}
goto cleanup;
}
if(cfg.no_retain && cfg.retained_only){
fprintf(stderr, "\nError: Combining '-R' and '--retained-only' makes no sense.\n");
goto cleanup;
}
if(client_id_generate(&cfg,"mosqsub")){
goto cleanup;
}
mosq = mosquitto_new(cfg.id, cfg.clean_session, &cfg);
if(!mosq){
switch(errno){
case ENOMEM:
//err_printf(&cfg, "Error: Out of memory.\n");
break;
case EINVAL:
//err_printf(&cfg, "Error: Invalid id and/or clean_session.\n");
break;
}
goto cleanup;
}
if(client_opts_set(mosq, &cfg)){
goto cleanup;
}
if(cfg.debug){
mosquitto_log_callback_set(mosq, my_log_callback);
mosquitto_subscribe_callback_set(mosq, my_subscribe_callback);
}
mosquitto_connect_v5_callback_set(mosq, my_connect_callback);
mosquitto_message_v5_callback_set(mosq, my_message_callback);
mosquitto_misc_callback_set(mosq, mqtt_msg_publish_callback);
rc = client_connect(mosq, &cfg);
if(rc){
goto cleanup;
}
#ifndef WIN32
sigact.sa_handler = my_signal_handler;
sigemptyset(&sigact.sa_mask);
sigact.sa_flags = 0;
if(sigaction(SIGALRM, &sigact, NULL) == -1){
perror("sigaction");
goto cleanup;
}
if(cfg.timeout){
alarm(cfg.timeout);
}
#endif
//连接成功之后，开启线程
mqtt_msg_publish_proc(mosq);
//循环事件处理，遇到异常事件将退出该循环
rc = mosquitto_loop_forever(mosq, -1, 1);
mosquitto_destroy(mosq);
mosquitto_lib_cleanup();
if(cfg.msg_count>0 && rc == MOSQ_ERR_NO_CONN){
rc = 0;
}
client_config_cleanup(&cfg);
if(rc){
//err_printf(&cfg, "Error: %s\n", mosquitto_strerror(rc));
}
return rc;
cleanup:
mosquitto_lib_cleanup();
client_config_cleanup(&cfg);
return 1;
} 编译客户端程序，生成一个名为”mqtt_client”的可执行文件。
在服务端开启 mosquitto服务端。
运行命令：mosquitto -c /etc/mosquitto/mosquitto.conf&
如下图所示：
5.mqtt_client客户端消息发布。
运行客户端程序，如下图所示：
./mqtt_client -h 192.168.9.68 -p 1883 -t "subtopic/test"
参数说明:
-h:指定mqtt服务端地址
-p:指定mqtt服务端端口
-t:用于接收数据的订阅主题
运行订阅客户端mosquitto_sub，用来接收消息,如下图所示：
由上图可知，mqtt_client发布的消息已经被正确接收。
6.mqtt_client客户端消息订阅
运行发布客户端mosquitto_pub，给mqtt_client发布消息，如下所示：
从mqtt_client客户端查看消息订阅结果，如下图所示：
至此，mqtt_client客户端程序的发布与订阅功能已经基本验证完毕。
总结：经过修改的MQTT客户端程序，可以实现与服务端接入，为以后诸多领域下的终端、网关设备接入云平台提供了简单的实例，后期可基于该程序根据具体的业务进行完善以及优化，给开发人员或者运维人员提供方便。MQTT由于开放源代码，耗电量小等特点，将会其它消息推送领域会有更多的贡献，例如在物联网领域，传感器与服务器的通信，信息的收集，MQTT都可以作为考虑的方案之一。在未来MQTT会进入到我们生活的各个方面。