service/protocol-plugin/plugins/mqtt-fan/lib/cpp/mosquittopp.cpp

   1 /*
   2 Copyright (c) 2010-2013 Roger Light <roger@atchoo.org>
   3 All rights reserved.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions are met:
   7
   8 1. Redistributions of source code must retain the above copyright notice,
   9    this list of conditions and the following disclaimer.
  10 2. Redistributions in binary form must reproduce the above copyright
  11    notice, this list of conditions and the following disclaimer in the
  12    documentation and/or other materials provided with the distribution.
  13 3. Neither the name of mosquitto nor the names of its
  14    contributors may be used to endorse or promote products derived from
  15    this software without specific prior written permission.
  16
  17 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  18 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  21 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  22 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  25 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  26 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  27 POSSIBILITY OF SUCH DAMAGE.
  28 */
  29
  30 #include <cstdlib>
  31 #include <mosquitto.h>
  32 #include <mosquittopp.h>
  33
  34 namespace mosqpp
  35 {
  36
  37     static void on_connect_wrapper(struct mosquitto *mosq, void *userdata, int rc)
  38     {
  39         class mosquittopp *m = (class mosquittopp *)userdata;
  40         m->on_connect(rc);
  41     }
  42
  43     static void on_disconnect_wrapper(struct mosquitto *mosq, void *userdata, int rc)
  44     {
  45         class mosquittopp *m = (class mosquittopp *)userdata;
  46         m->on_disconnect(rc);
  47     }
  48
  49     static void on_publish_wrapper(struct mosquitto *mosq, void *userdata, int mid)
  50     {
  51         class mosquittopp *m = (class mosquittopp *)userdata;
  52         m->on_publish(mid);
  53     }
  54
  55     static void on_message_wrapper(struct mosquitto *mosq, void *userdata,
  56                                    const struct mosquitto_message *message)
  57     {
  58         class mosquittopp *m = (class mosquittopp *)userdata;
  59         m->on_message(message);
  60     }
  61
  62     static void on_subscribe_wrapper(struct mosquitto *mosq, void *userdata, int mid, int qos_count,
  63                                      const int *granted_qos)
  64     {
  65         class mosquittopp *m = (class mosquittopp *)userdata;
  66         m->on_subscribe(mid, qos_count, granted_qos);
  67     }
  68
  69     static void on_unsubscribe_wrapper(struct mosquitto *mosq, void *userdata, int mid)
  70     {
  71         class mosquittopp *m = (class mosquittopp *)userdata;
  72         m->on_unsubscribe(mid);
  73     }
  74
  75
  76     static void on_log_wrapper(struct mosquitto *mosq, void *userdata, int level, const char *str)
  77     {
  78         class mosquittopp *m = (class mosquittopp *)userdata;
  79         m->on_log(level, str);
  80     }
  81
  82     int lib_version(int *major, int *minor, int *revision)
  83     {
  84         if (major) *major = LIBMOSQUITTO_MAJOR;
  85         if (minor) *minor = LIBMOSQUITTO_MINOR;
  86         if (revision) *revision = LIBMOSQUITTO_REVISION;
  87         return LIBMOSQUITTO_VERSION_NUMBER;
  88     }
  89
  90     int lib_init()
  91     {
  92         return mosquitto_lib_init();
  93     }
  94
  95     int lib_cleanup()
  96     {
  97         return mosquitto_lib_cleanup();
  98     }
  99
 100     const char *strerror(int mosq_errno)
 101     {
 102         return mosquitto_strerror(mosq_errno);
 103     }
 104
 105     const char *connack_string(int connack_code)
 106     {
 107         return mosquitto_connack_string(connack_code);
 108     }
 109
 110     int sub_topic_tokenise(const char *subtopic, char ***topics, int *count)
 111     {
 112         return mosquitto_sub_topic_tokenise(subtopic, topics, count);
 113     }
 114
 115     int sub_topic_tokens_free(char ***topics, int count)
 116     {
 117         return mosquitto_sub_topic_tokens_free(topics, count);
 118     }
 119
 120     int topic_matches_sub(const char *sub, const char *topic, bool *result)
 121     {
 122         return mosquitto_topic_matches_sub(sub, topic, result);
 123     }
 124
 125     mosquittopp::mosquittopp(const char *id, bool clean_session)
 126     {
 127         m_mosq = mosquitto_new(id, clean_session, this);
 128         mosquitto_connect_callback_set(m_mosq, on_connect_wrapper);
 129         mosquitto_disconnect_callback_set(m_mosq, on_disconnect_wrapper);
 130         mosquitto_publish_callback_set(m_mosq, on_publish_wrapper);
 131         mosquitto_message_callback_set(m_mosq, on_message_wrapper);
 132         mosquitto_subscribe_callback_set(m_mosq, on_subscribe_wrapper);
 133         mosquitto_unsubscribe_callback_set(m_mosq, on_unsubscribe_wrapper);
 134         mosquitto_log_callback_set(m_mosq, on_log_wrapper);
 135     }
 136
 137     mosquittopp::~mosquittopp()
 138     {
 139         mosquitto_destroy(m_mosq);
 140     }
 141
 142     int mosquittopp::reinitialise(const char *id, bool clean_session)
 143     {
 144         int rc;
 145         rc = mosquitto_reinitialise(m_mosq, id, clean_session, this);
 146         if (rc == MOSQ_ERR_SUCCESS)
 147         {
 148             mosquitto_connect_callback_set(m_mosq, on_connect_wrapper);
 149             mosquitto_disconnect_callback_set(m_mosq, on_disconnect_wrapper);
 150             mosquitto_publish_callback_set(m_mosq, on_publish_wrapper);
 151             mosquitto_message_callback_set(m_mosq, on_message_wrapper);
 152             mosquitto_subscribe_callback_set(m_mosq, on_subscribe_wrapper);
 153             mosquitto_unsubscribe_callback_set(m_mosq, on_unsubscribe_wrapper);
 154             mosquitto_log_callback_set(m_mosq, on_log_wrapper);
 155         }
 156         return rc;
 157     }
 158
 159     int mosquittopp::connect(const char *host, int port, int keepalive)
 160     {
 161         return mosquitto_connect(m_mosq, host, port, keepalive);
 162     }
 163
 164     int mosquittopp::connect(const char *host, int port, int keepalive, const char *bind_address)
 165     {
 166         return mosquitto_connect_bind(m_mosq, host, port, keepalive, bind_address);
 167     }
 168
 169     int mosquittopp::connect_async(const char *host, int port, int keepalive)
 170     {
 171         return mosquitto_connect_async(m_mosq, host, port, keepalive);
 172     }
 173
 174     int mosquittopp::connect_async(const char *host, int port, int keepalive, const char *bind_address)
 175     {
 176         return mosquitto_connect_bind_async(m_mosq, host, port, keepalive, bind_address);
 177     }
 178
 179     int mosquittopp::reconnect()
 180     {
 181         return mosquitto_reconnect(m_mosq);
 182     }
 183
 184     int mosquittopp::reconnect_async()
 185     {
 186         return mosquitto_reconnect_async(m_mosq);
 187     }
 188
 189     int mosquittopp::disconnect()
 190     {
 191         return mosquitto_disconnect(m_mosq);
 192     }
 193
 194     int mosquittopp::socket()
 195     {
 196         return mosquitto_socket(m_mosq);
 197     }
 198
 199     int mosquittopp::will_set(const char *topic, int payloadlen, const void *payload, int qos,
 200                               bool retain)
 201     {
 202         return mosquitto_will_set(m_mosq, topic, payloadlen, payload, qos, retain);
 203     }
 204
 205     int mosquittopp::will_clear()
 206     {
 207         return mosquitto_will_clear(m_mosq);
 208     }
 209
 210     int mosquittopp::username_pw_set(const char *username, const char *password)
 211     {
 212         return mosquitto_username_pw_set(m_mosq, username, password);
 213     }
 214
 215     int mosquittopp::publish(int *mid, const char *topic, int payloadlen, const void *payload, int qos,
 216                              bool retain)
 217     {
 218         return mosquitto_publish(m_mosq, mid, topic, payloadlen, payload, qos, retain);
 219     }
 220
 221     void mosquittopp::reconnect_delay_set(unsigned int reconnect_delay,
 222                                           unsigned int reconnect_delay_max, bool reconnect_exponential_backoff)
 223     {
 224         mosquitto_reconnect_delay_set(m_mosq, reconnect_delay, reconnect_delay_max,
 225                                       reconnect_exponential_backoff);
 226     }
 227
 228     int mosquittopp::max_inflight_messages_set(unsigned int max_inflight_messages)
 229     {
 230         return mosquitto_max_inflight_messages_set(m_mosq, max_inflight_messages);
 231     }
 232
 233     void mosquittopp::message_retry_set(unsigned int message_retry)
 234     {
 235         mosquitto_message_retry_set(m_mosq, message_retry);
 236     }
 237
 238     int mosquittopp::subscribe(int *mid, const char *sub, int qos)
 239     {
 240         return mosquitto_subscribe(m_mosq, mid, sub, qos);
 241     }
 242
 243     int mosquittopp::unsubscribe(int *mid, const char *sub)
 244     {
 245         return mosquitto_unsubscribe(m_mosq, mid, sub);
 246     }
 247
 248     int mosquittopp::loop(int timeout, int max_packets)
 249     {
 250         return mosquitto_loop(m_mosq, timeout, max_packets);
 251     }
 252
 253     int mosquittopp::loop_misc()
 254     {
 255         return mosquitto_loop_misc(m_mosq);
 256     }
 257
 258     int mosquittopp::loop_read(int max_packets)
 259     {
 260         return mosquitto_loop_read(m_mosq, max_packets);
 261     }
 262
 263     int mosquittopp::loop_write(int max_packets)
 264     {
 265         return mosquitto_loop_write(m_mosq, max_packets);
 266     }
 267
 268     int mosquittopp::loop_forever(int timeout, int max_packets)
 269     {
 270         return mosquitto_loop_forever(m_mosq, timeout, max_packets);
 271     }
 272
 273     int mosquittopp::loop_start()
 274     {
 275         return mosquitto_loop_start(m_mosq);
 276     }
 277
 278     int mosquittopp::loop_stop(bool force)
 279     {
 280         return mosquitto_loop_stop(m_mosq, force);
 281     }
 282
 283     bool mosquittopp::want_write()
 284     {
 285         return mosquitto_want_write(m_mosq);
 286     }
 287
 288     void mosquittopp::user_data_set(void *userdata)
 289     {
 290         mosquitto_user_data_set(m_mosq, userdata);
 291     }
 292
 293     int mosquittopp::tls_set(const char *cafile, const char *capath, const char *certfile,
 294                              const char *keyfile, int (*pw_callback)(char *buf, int size, int rwflag, void *userdata))
 295     {
 296         return mosquitto_tls_set(m_mosq, cafile, capath, certfile, keyfile, pw_callback);
 297     }
 298
 299     int mosquittopp::tls_opts_set(int cert_reqs, const char *tls_version, const char *ciphers)
 300     {
 301         return mosquitto_tls_opts_set(m_mosq, cert_reqs, tls_version, ciphers);
 302     }
 303
 304     int mosquittopp::tls_insecure_set(bool value)
 305     {
 306         return mosquitto_tls_insecure_set(m_mosq, value);
 307     }
 308
 309     int mosquittopp::tls_psk_set(const char *psk, const char *identity, const char *ciphers)
 310     {
 311         return mosquitto_tls_psk_set(m_mosq, psk, identity, ciphers);
 312     }
 313
 314 }