mqtt.c 50 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587
  1. // Module for mqtt
  2. //
  3. #include "module.h"
  4. #include "lauxlib.h"
  5. #include "platform.h"
  6. #include <string.h>
  7. #include <stddef.h>
  8. #include <stdint.h>
  9. #include "mem.h"
  10. #include "lwip/ip_addr.h"
  11. #include "espconn.h"
  12. #include "mqtt/mqtt_msg.h"
  13. #include "mqtt/msg_queue.h"
  14. #include "user_interface.h"
  15. #define MQTT_BUF_SIZE 1460
  16. #define MQTT_DEFAULT_KEEPALIVE 60
  17. #define MQTT_MAX_CLIENT_LEN 64
  18. #define MQTT_MAX_USER_LEN 64
  19. #define MQTT_MAX_PASS_LEN 64
  20. #define MQTT_SEND_TIMEOUT 5 /* seconds */
  21. typedef enum {
  22. MQTT_INIT,
  23. MQTT_CONNECT_SENDING,
  24. MQTT_CONNECT_SENT,
  25. MQTT_DATA
  26. } tConnState;
  27. typedef struct mqtt_event_data_t
  28. {
  29. uint8_t type;
  30. const char* topic;
  31. const char* data;
  32. uint16_t topic_length;
  33. uint16_t data_length;
  34. uint16_t data_offset;
  35. } mqtt_event_data_t;
  36. typedef enum {
  37. MQTT_RECV_NORMAL,
  38. MQTT_RECV_BUFFERING_SHORT,
  39. MQTT_RECV_BUFFERING,
  40. MQTT_RECV_SKIPPING,
  41. } tReceiveState;
  42. typedef struct mqtt_state_t
  43. {
  44. msg_queue_t* pending_msg_q;
  45. uint16_t next_message_id;
  46. uint8_t * recv_buffer; // heap buffer for multi-packet rx
  47. uint8_t * recv_buffer_wp; // write pointer in multi-packet rx
  48. union {
  49. uint16_t recv_buffer_size; // size of recv_buffer
  50. uint32_t recv_buffer_skip; // number of bytes left to skip, in skipping state
  51. };
  52. tReceiveState recv_buffer_state;
  53. } mqtt_state_t;
  54. typedef struct lmqtt_userdata
  55. {
  56. struct espconn pesp_conn;
  57. int self_ref;
  58. int cb_connect_ref;
  59. int cb_connect_fail_ref;
  60. int cb_disconnect_ref;
  61. int cb_message_ref;
  62. int cb_overflow_ref;
  63. int cb_suback_ref;
  64. int cb_unsuback_ref;
  65. int cb_puback_ref;
  66. /* Configuration options */
  67. struct {
  68. int client_id_ref;
  69. int username_ref;
  70. int password_ref;
  71. int will_topic_ref;
  72. int will_message_ref;
  73. int keepalive;
  74. uint16_t max_message_length;
  75. struct {
  76. unsigned will_qos : 2;
  77. bool will_retain : 1;
  78. bool clean_session : 1;
  79. bool secure : 1;
  80. } flags;
  81. } conf;
  82. mqtt_state_t mqtt_state;
  83. bool connected; // indicate socket connected, not mqtt prot connected.
  84. bool keepalive_sent;
  85. bool sending; // data sent to network stack, awaiting local acknowledge
  86. ETSTimer mqttTimer;
  87. tConnState connState;
  88. }lmqtt_userdata;
  89. // How large MQTT messages to accept by default
  90. #define DEFAULT_MAX_MESSAGE_LENGTH 1024
  91. static sint8 mqtt_socket_do_connect(struct lmqtt_userdata *);
  92. static void mqtt_socket_reconnected(void *arg, sint8_t err);
  93. static void mqtt_socket_connected(void *arg);
  94. static void mqtt_connack_fail(lmqtt_userdata * mud, int reason_code);
  95. static uint16_t mqtt_next_message_id(lmqtt_userdata * mud)
  96. {
  97. mud->mqtt_state.next_message_id++;
  98. if (mud->mqtt_state.next_message_id == 0)
  99. mud->mqtt_state.next_message_id++;
  100. return mud->mqtt_state.next_message_id;
  101. }
  102. static void mqtt_socket_cb_lua_noarg(lua_State *L, lmqtt_userdata *mud, int cb)
  103. {
  104. if (cb == LUA_NOREF)
  105. return;
  106. lua_rawgeti(L, LUA_REGISTRYINDEX, cb);
  107. lua_rawgeti(L, LUA_REGISTRYINDEX, mud->self_ref);
  108. lua_call(L, 1, 0);
  109. }
  110. static void mqtt_socket_disconnected(void *arg) // tcp only
  111. {
  112. NODE_DBG("enter mqtt_socket_disconnected.\n");
  113. lmqtt_userdata *mud = arg;
  114. if(mud == NULL)
  115. return;
  116. os_timer_disarm(&mud->mqttTimer);
  117. while (mud->mqtt_state.pending_msg_q) {
  118. msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q)));
  119. }
  120. if(mud->mqtt_state.recv_buffer) {
  121. free(mud->mqtt_state.recv_buffer);
  122. mud->mqtt_state.recv_buffer = NULL;
  123. }
  124. mud->mqtt_state.recv_buffer_size = 0;
  125. mud->mqtt_state.recv_buffer_state = MQTT_RECV_NORMAL;
  126. if(mud->pesp_conn.proto.tcp)
  127. free(mud->pesp_conn.proto.tcp);
  128. mud->pesp_conn.proto.tcp = NULL;
  129. int selfref = mud->self_ref;
  130. mud->self_ref = LUA_NOREF;
  131. lua_State *L = lua_getstate();
  132. if(mud->connected){ // call back only called when socket is from connection to disconnection.
  133. mud->connected = false;
  134. if((mud->cb_disconnect_ref != LUA_NOREF) && (selfref != LUA_NOREF)) {
  135. lua_rawgeti(L, LUA_REGISTRYINDEX, mud->cb_disconnect_ref);
  136. lua_rawgeti(L, LUA_REGISTRYINDEX, selfref);
  137. lua_call(L, 1, 0);
  138. }
  139. }
  140. // unref this, and the mqtt.socket userdata will delete it self
  141. luaL_unref(L, LUA_REGISTRYINDEX, selfref);
  142. NODE_DBG("leave mqtt_socket_disconnected.\n");
  143. }
  144. static void mqtt_socket_do_disconnect(struct lmqtt_userdata *mud)
  145. {
  146. #ifdef CLIENT_SSL_ENABLE
  147. if (mud->conf.flags.secure) {
  148. espconn_secure_disconnect(&mud->pesp_conn);
  149. } else
  150. #endif
  151. {
  152. espconn_disconnect(&mud->pesp_conn);
  153. }
  154. }
  155. static void mqtt_socket_reconnected(void *arg, sint8_t err)
  156. {
  157. NODE_DBG("enter mqtt_socket_reconnected (err=%d)\n", err);
  158. lmqtt_userdata *mud = arg;
  159. if(mud == NULL)
  160. return;
  161. os_timer_disarm(&mud->mqttTimer);
  162. mqtt_connack_fail(mud, MQTT_CONN_FAIL_SERVER_NOT_FOUND);
  163. mqtt_socket_disconnected(arg);
  164. NODE_DBG("leave mqtt_socket_reconnected.\n");
  165. }
  166. static void deliver_publish(lmqtt_userdata * mud, uint8_t* message, uint16_t length, uint8_t is_overflow)
  167. {
  168. NODE_DBG("enter deliver_publish (len=%d, overflow=%d).\n", length, is_overflow);
  169. if(mud == NULL)
  170. return;
  171. mqtt_event_data_t event_data;
  172. event_data.topic_length = length;
  173. event_data.topic = mqtt_get_publish_topic(message, &event_data.topic_length);
  174. event_data.data_length = length;
  175. event_data.data = mqtt_get_publish_data(message, &event_data.data_length);
  176. int cb_ref = !is_overflow ? mud->cb_message_ref : mud->cb_overflow_ref;
  177. if(cb_ref == LUA_NOREF)
  178. return;
  179. if(mud->self_ref == LUA_NOREF)
  180. return;
  181. lua_State *L = lua_getstate();
  182. if(event_data.topic && (event_data.topic_length > 0)){
  183. lua_rawgeti(L, LUA_REGISTRYINDEX, cb_ref);
  184. lua_rawgeti(L, LUA_REGISTRYINDEX, mud->self_ref);
  185. lua_pushlstring(L, event_data.topic, event_data.topic_length);
  186. } else {
  187. NODE_DBG("get wrong packet.\n");
  188. return;
  189. }
  190. if(event_data.data && (event_data.data_length > 0)){
  191. lua_pushlstring(L, event_data.data, event_data.data_length);
  192. lua_call(L, 3, 0);
  193. } else {
  194. lua_call(L, 2, 0);
  195. }
  196. NODE_DBG("leave deliver_publish.\n");
  197. }
  198. static void mqtt_connack_fail(lmqtt_userdata * mud, int reason_code)
  199. {
  200. NODE_DBG("enter mqtt_connack_fail\n");
  201. if(mud->cb_connect_fail_ref == LUA_NOREF || mud->self_ref == LUA_NOREF)
  202. {
  203. return;
  204. }
  205. lua_State *L = lua_getstate();
  206. lua_rawgeti(L, LUA_REGISTRYINDEX, mud->cb_connect_fail_ref);
  207. lua_rawgeti(L, LUA_REGISTRYINDEX, mud->self_ref);
  208. lua_pushinteger(L, reason_code);
  209. lua_call(L, 2, 0);
  210. NODE_DBG("leave mqtt_connack_fail\n");
  211. }
  212. static sint8 mqtt_send_if_possible(struct lmqtt_userdata *mud)
  213. {
  214. /* Waiting for the local network stack to get back to us? Can't send. */
  215. if (mud->sending)
  216. return ESPCONN_OK;
  217. sint8 espconn_status = ESPCONN_OK;
  218. msg_queue_t *pending_msg = msg_peek(&(mud->mqtt_state.pending_msg_q));
  219. if (pending_msg && !pending_msg->sent) {
  220. pending_msg->sent = 1;
  221. NODE_DBG("Sent: %d\n", pending_msg->msg.length);
  222. #ifdef CLIENT_SSL_ENABLE
  223. if( mud->conf.flags.secure )
  224. {
  225. espconn_status = espconn_secure_send(&mud->pesp_conn, pending_msg->msg.data, pending_msg->msg.length );
  226. }
  227. else
  228. #endif
  229. {
  230. espconn_status = espconn_send(&mud->pesp_conn, pending_msg->msg.data, pending_msg->msg.length );
  231. }
  232. mud->sending = true;
  233. os_timer_disarm(&mud->mqttTimer);
  234. os_timer_arm(&mud->mqttTimer, MQTT_SEND_TIMEOUT * 1000, 0);
  235. }
  236. NODE_DBG("send_if_poss, queue size: %d\n", msg_size(&(mud->mqtt_state.pending_msg_q)));
  237. return espconn_status;
  238. }
  239. static void mqtt_socket_received(void *arg, char *pdata, unsigned short len)
  240. {
  241. NODE_DBG("enter mqtt_socket_received (rxlen=%u).\n", len);
  242. uint8_t msg_type;
  243. uint8_t msg_qos;
  244. uint16_t msg_id;
  245. uint8_t *in_buffer = (uint8_t *)pdata;
  246. uint16_t in_buffer_length = len;
  247. uint8_t *continuation_buffer = NULL;
  248. uint8_t *temp_pdata = NULL;
  249. lmqtt_userdata *mud = arg;
  250. if(mud == NULL)
  251. return;
  252. switch(mud->mqtt_state.recv_buffer_state) {
  253. case MQTT_RECV_NORMAL:
  254. // No previous buffer.
  255. break;
  256. case MQTT_RECV_BUFFERING_SHORT:
  257. // Last buffer had so few byte that we could not determine message length.
  258. // Store in a local heap buffer and operate on this, as if was the regular pdata buffer.
  259. // Avoids having to repeat message size/overflow logic.
  260. temp_pdata = calloc(1,mud->mqtt_state.recv_buffer_size + len);
  261. if(temp_pdata == NULL) {
  262. NODE_DBG("MQTT[buffering-short]: Failed to allocate %u bytes, disconnecting...\n", mud->mqtt_state.recv_buffer_size + len);
  263. mqtt_socket_do_disconnect(mud);
  264. return;
  265. }
  266. NODE_DBG("MQTT[buffering-short]: Continuing with %u + %u bytes\n", mud->mqtt_state.recv_buffer_size, len);
  267. memcpy(temp_pdata, mud->mqtt_state.recv_buffer, mud->mqtt_state.recv_buffer_size);
  268. memcpy(temp_pdata + mud->mqtt_state.recv_buffer_size, pdata, len);
  269. free(mud->mqtt_state.recv_buffer);
  270. mud->mqtt_state.recv_buffer = NULL;
  271. mud->mqtt_state.recv_buffer_state = MQTT_RECV_NORMAL;
  272. in_buffer = temp_pdata;
  273. in_buffer_length = mud->mqtt_state.recv_buffer_size + len;
  274. break;
  275. case MQTT_RECV_BUFFERING: {
  276. // safe cast: we never allow longer buffer.
  277. uint16_t current_length = (uint16_t) (mud->mqtt_state.recv_buffer_wp - mud->mqtt_state.recv_buffer);
  278. NODE_DBG("MQTT[buffering]: appending %u bytes to previous recv buffer (%u out of wanted %u)\n",
  279. in_buffer_length,
  280. current_length,
  281. mud->mqtt_state.recv_buffer_size);
  282. // Copy from rx buffer to heap buffer. Smallest of [remainder of pending message] and [all of buffer]
  283. uint16_t copy_length = LWIP_MIN(mud->mqtt_state.recv_buffer_size - current_length, in_buffer_length);
  284. memcpy(mud->mqtt_state.recv_buffer_wp, pdata, copy_length);
  285. mud->mqtt_state.recv_buffer_wp += copy_length;
  286. in_buffer_length = (uint16_t) (mud->mqtt_state.recv_buffer_wp - mud->mqtt_state.recv_buffer);
  287. if (in_buffer_length < mud->mqtt_state.recv_buffer_size) {
  288. NODE_DBG("MQTT[buffering]: need %u more bytes, waiting for next rx.\n",
  289. mud->mqtt_state.recv_buffer_size - in_buffer_length
  290. );
  291. goto RX_PACKET_FINISHED;
  292. }
  293. NODE_DBG("MQTT[buffering]: Full message received (%u). remainding bytes=%u\n",
  294. mud->mqtt_state.recv_buffer_size,
  295. len - copy_length);
  296. // Point continuation_buffer to any additional data in pdata.
  297. // May become 0 bytes, but used to trigger free!
  298. continuation_buffer = pdata + copy_length;
  299. len -= copy_length; // borrow len instead of having another variable..
  300. in_buffer = mud->mqtt_state.recv_buffer;
  301. // in_buffer_length was set above
  302. mud->mqtt_state.recv_buffer_state = MQTT_RECV_NORMAL;
  303. break;
  304. }
  305. case MQTT_RECV_SKIPPING:
  306. // Last rx had a message which was too large to process, skip it.
  307. if(mud->mqtt_state.recv_buffer_skip > in_buffer_length) {
  308. NODE_DBG("MQTT[skipping]: skip=%u. Skipping full RX buffer (%u).\n",
  309. mud->mqtt_state.recv_buffer_skip,
  310. in_buffer_length
  311. );
  312. mud->mqtt_state.recv_buffer_skip -= in_buffer_length;
  313. goto RX_PACKET_FINISHED;
  314. }
  315. NODE_DBG("MQTT[skipping]: skip=%u. Skipping partial RX buffer, continuing at %u\n",
  316. mud->mqtt_state.recv_buffer_skip,
  317. in_buffer_length
  318. );
  319. in_buffer += mud->mqtt_state.recv_buffer_skip;
  320. in_buffer_length -= mud->mqtt_state.recv_buffer_skip;
  321. mud->mqtt_state.recv_buffer_skip = 0;
  322. mud->mqtt_state.recv_buffer_state = MQTT_RECV_NORMAL;
  323. break;
  324. }
  325. READPACKET:
  326. if(in_buffer_length <= 0)
  327. goto RX_PACKET_FINISHED;
  328. // MQTT publish message can in theory be 256Mb, while we do not support it we need to be
  329. // able to do math on it.
  330. int32_t message_length;
  331. // temp buffer for control messages
  332. uint8_t temp_buffer[MQTT_BUF_SIZE];
  333. mqtt_message_buffer_t msgb;
  334. mqtt_msg_init(&msgb, temp_buffer, MQTT_BUF_SIZE);
  335. mqtt_message_t *temp_msg = NULL;
  336. switch(mud->connState){
  337. case MQTT_CONNECT_SENDING:
  338. case MQTT_CONNECT_SENT:
  339. os_timer_disarm(&mud->mqttTimer);
  340. os_timer_arm(&mud->mqttTimer, mud->conf.keepalive * 1000, 0);
  341. if(mqtt_get_type(in_buffer) != MQTT_MSG_TYPE_CONNACK){
  342. NODE_DBG("MQTT: Invalid packet\r\n");
  343. mud->connState = MQTT_INIT;
  344. mqtt_socket_do_disconnect(mud);
  345. mqtt_connack_fail(mud, MQTT_CONN_FAIL_NOT_A_CONNACK_MSG);
  346. break;
  347. } else if (mqtt_get_connect_ret_code(in_buffer) != MQTT_CONNACK_ACCEPTED) {
  348. NODE_DBG("MQTT: CONNACK REFUSED (CODE: %d)\n", mqtt_get_connect_ret_code(in_buffer));
  349. mud->connState = MQTT_INIT;
  350. mqtt_socket_do_disconnect(mud);
  351. mqtt_connack_fail(mud, mqtt_get_connect_ret_code(in_buffer));
  352. break;
  353. } else {
  354. mud->connState = MQTT_DATA;
  355. NODE_DBG("MQTT: Connected\r\n");
  356. mud->keepalive_sent = 0;
  357. mqtt_socket_cb_lua_noarg(lua_getstate(), mud, mud->cb_connect_ref);
  358. break;
  359. }
  360. break;
  361. case MQTT_DATA:
  362. message_length = mqtt_get_total_length(in_buffer, in_buffer_length);
  363. msg_type = mqtt_get_type(in_buffer);
  364. msg_qos = mqtt_get_qos(in_buffer);
  365. msg_id = mqtt_get_id(in_buffer, in_buffer_length);
  366. NODE_DBG("MQTT_DATA: msg length: %u, buffer length: %u\r\n",
  367. message_length,
  368. in_buffer_length);
  369. if (message_length > mud->conf.max_message_length) {
  370. // The pending message length is larger than we was configured to allow
  371. if(msg_qos > 0 && msg_id == 0) {
  372. NODE_DBG("MQTT: msg too long, but not enough data to get msg_id: total=%u, deliver=%u\r\n", message_length, in_buffer_length);
  373. // qos requested, but too short buffer to get a packet ID.
  374. // Trigger the "short buffer" mode
  375. message_length = -1;
  376. // Drop through to partial message handling below.
  377. } else {
  378. NODE_DBG("MQTT: msg too long: total=%u, deliver=%u\r\n", message_length, in_buffer_length);
  379. if (msg_type == MQTT_MSG_TYPE_PUBLISH) {
  380. // In practice we should never get any other types..
  381. deliver_publish(mud, in_buffer, in_buffer_length, 1);
  382. // If qos specified, we should ACK it.
  383. // In theory it might be wrong to ack it before we received all TCP packets, but this avoids
  384. // buffering and special code to handle this corner-case. Server will most likely have
  385. // written all to OS socket anyway, and not be aware that we "should" not have received it all yet.
  386. if(msg_qos == 1){
  387. temp_msg = mqtt_msg_puback(&msgb, msg_id);
  388. msg_enqueue(&(mud->mqtt_state.pending_msg_q), temp_msg,
  389. msg_id, MQTT_MSG_TYPE_PUBACK, (int)mqtt_get_qos(temp_msg->data) );
  390. }
  391. else if(msg_qos == 2){
  392. temp_msg = mqtt_msg_pubrec(&msgb, msg_id);
  393. msg_enqueue(&(mud->mqtt_state.pending_msg_q), temp_msg,
  394. msg_id, MQTT_MSG_TYPE_PUBREC, (int)mqtt_get_qos(temp_msg->data) );
  395. }
  396. if(msg_qos == 1 || msg_qos == 2){
  397. NODE_DBG("MQTT: Queue response QoS: %d\r\n", msg_qos);
  398. }
  399. }
  400. if (message_length > in_buffer_length) {
  401. // Ignore bytes in subsequent packet(s) too.
  402. NODE_DBG("MQTT: skipping into next rx\n");
  403. mud->mqtt_state.recv_buffer_state = MQTT_RECV_SKIPPING;
  404. mud->mqtt_state.recv_buffer_skip = (uint32_t) message_length - in_buffer_length;
  405. break;
  406. } else {
  407. NODE_DBG("MQTT: Skipping message\n");
  408. mud->mqtt_state.recv_buffer_state = MQTT_RECV_NORMAL;
  409. goto RX_MESSAGE_PROCESSED;
  410. }
  411. }
  412. }
  413. if (message_length == -1 || message_length > in_buffer_length) {
  414. // Partial message in buffer, need to store on heap until next RX. Allocate size for full message directly,
  415. // instead of potential reallocs, to avoid fragmentation.
  416. // If message_length is indicated as -1, we do not have enough data to determine the length properly.
  417. // Just put what we have on heap, and place in state BUFFERING_SHORT.
  418. NODE_DBG("MQTT: Partial message received (%u of %d). Buffering\r\n",
  419. in_buffer_length,
  420. message_length);
  421. // although message_length is 32bit, it should never go above 16bit since
  422. // max_message_length is 16bit.
  423. uint16_t alloc_size = message_length > 0 ? (uint16_t)message_length : in_buffer_length;
  424. mud->mqtt_state.recv_buffer = calloc(1,alloc_size);
  425. if (mud->mqtt_state.recv_buffer == NULL) {
  426. NODE_DBG("MQTT: Failed to allocate %u bytes, disconnecting...\n", alloc_size);
  427. mqtt_socket_do_disconnect(mud);
  428. return;
  429. }
  430. memcpy(mud->mqtt_state.recv_buffer, in_buffer, in_buffer_length);
  431. mud->mqtt_state.recv_buffer_wp = mud->mqtt_state.recv_buffer + in_buffer_length;
  432. mud->mqtt_state.recv_buffer_state = message_length > 0 ? MQTT_RECV_BUFFERING : MQTT_RECV_BUFFERING_SHORT;
  433. mud->mqtt_state.recv_buffer_size = alloc_size;
  434. NODE_DBG("MQTT: Wait for next recv\n");
  435. break;
  436. }
  437. msg_queue_t *pending_msg = msg_peek(&(mud->mqtt_state.pending_msg_q));
  438. NODE_DBG("MQTT_DATA: type: %d, qos: %d, msg_id: %d, pending_id: %d, msg length: %u, buffer length: %u\r\n",
  439. msg_type,
  440. msg_qos,
  441. msg_id,
  442. (pending_msg)?pending_msg->msg_id:0,
  443. message_length,
  444. in_buffer_length);
  445. switch(msg_type)
  446. {
  447. case MQTT_MSG_TYPE_SUBACK:
  448. if(pending_msg && pending_msg->msg_type == MQTT_MSG_TYPE_SUBSCRIBE && pending_msg->msg_id == msg_id){
  449. NODE_DBG("MQTT: Subscribe successful\r\n");
  450. msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q)));
  451. mqtt_socket_cb_lua_noarg(lua_getstate(), mud, mud->cb_suback_ref);
  452. }
  453. break;
  454. case MQTT_MSG_TYPE_UNSUBACK:
  455. if(pending_msg && pending_msg->msg_type == MQTT_MSG_TYPE_UNSUBSCRIBE && pending_msg->msg_id == msg_id){
  456. NODE_DBG("MQTT: UnSubscribe successful\r\n");
  457. msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q)));
  458. mqtt_socket_cb_lua_noarg(lua_getstate(), mud, mud->cb_unsuback_ref);
  459. }
  460. break;
  461. case MQTT_MSG_TYPE_PUBLISH:
  462. if(msg_qos == 1){
  463. temp_msg = mqtt_msg_puback(&msgb, msg_id);
  464. msg_enqueue(&(mud->mqtt_state.pending_msg_q), temp_msg,
  465. msg_id, MQTT_MSG_TYPE_PUBACK, (int)mqtt_get_qos(temp_msg->data) );
  466. }
  467. else if(msg_qos == 2){
  468. temp_msg = mqtt_msg_pubrec(&msgb, msg_id);
  469. msg_enqueue(&(mud->mqtt_state.pending_msg_q), temp_msg,
  470. msg_id, MQTT_MSG_TYPE_PUBREC, (int)mqtt_get_qos(temp_msg->data) );
  471. }
  472. if(msg_qos == 1 || msg_qos == 2){
  473. NODE_DBG("MQTT: Queue response QoS: %d\r\n", msg_qos);
  474. }
  475. deliver_publish(mud, in_buffer, (uint16_t)message_length, 0);
  476. break;
  477. case MQTT_MSG_TYPE_PUBACK:
  478. if(pending_msg && pending_msg->msg_type == MQTT_MSG_TYPE_PUBLISH && pending_msg->msg_id == msg_id){
  479. NODE_DBG("MQTT: Publish with QoS = 1 successful\r\n");
  480. msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q)));
  481. mqtt_socket_cb_lua_noarg(lua_getstate(), mud, mud->cb_puback_ref);
  482. }
  483. break;
  484. case MQTT_MSG_TYPE_PUBREC:
  485. if(pending_msg && pending_msg->msg_type == MQTT_MSG_TYPE_PUBLISH && pending_msg->msg_id == msg_id){
  486. NODE_DBG("MQTT: Publish with QoS = 2 Received PUBREC\r\n");
  487. // Note: actually, should not destroy the msg until PUBCOMP is received.
  488. msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q)));
  489. temp_msg = mqtt_msg_pubrel(&msgb, msg_id);
  490. msg_enqueue(&(mud->mqtt_state.pending_msg_q), temp_msg,
  491. msg_id, MQTT_MSG_TYPE_PUBREL, (int)mqtt_get_qos(temp_msg->data) );
  492. NODE_DBG("MQTT: Response PUBREL\r\n");
  493. }
  494. break;
  495. case MQTT_MSG_TYPE_PUBREL:
  496. if(pending_msg && pending_msg->msg_type == MQTT_MSG_TYPE_PUBREC && pending_msg->msg_id == msg_id){
  497. msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q)));
  498. temp_msg = mqtt_msg_pubcomp(&msgb, msg_id);
  499. msg_enqueue(&(mud->mqtt_state.pending_msg_q), temp_msg,
  500. msg_id, MQTT_MSG_TYPE_PUBCOMP, (int)mqtt_get_qos(temp_msg->data) );
  501. NODE_DBG("MQTT: Response PUBCOMP\r\n");
  502. }
  503. break;
  504. case MQTT_MSG_TYPE_PUBCOMP:
  505. if(pending_msg && pending_msg->msg_type == MQTT_MSG_TYPE_PUBREL && pending_msg->msg_id == msg_id){
  506. NODE_DBG("MQTT: Publish with QoS = 2 successful\r\n");
  507. msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q)));
  508. mqtt_socket_cb_lua_noarg(lua_getstate(), mud, mud->cb_puback_ref);
  509. }
  510. break;
  511. case MQTT_MSG_TYPE_PINGREQ:
  512. temp_msg = mqtt_msg_pingresp(&msgb);
  513. msg_enqueue(&(mud->mqtt_state.pending_msg_q), temp_msg,
  514. msg_id, MQTT_MSG_TYPE_PINGRESP, (int)mqtt_get_qos(temp_msg->data) );
  515. NODE_DBG("MQTT: Response PINGRESP\r\n");
  516. break;
  517. case MQTT_MSG_TYPE_PINGRESP:
  518. // Ignore
  519. mud->keepalive_sent = 0;
  520. NODE_DBG("MQTT: PINGRESP received\r\n");
  521. break;
  522. }
  523. RX_MESSAGE_PROCESSED:
  524. if(continuation_buffer != NULL) {
  525. NODE_DBG("MQTT[buffering]: buffered message finished. Continuing with rest of rx buffer (%u)\n",
  526. len);
  527. free(mud->mqtt_state.recv_buffer);
  528. mud->mqtt_state.recv_buffer = NULL;
  529. in_buffer = continuation_buffer;
  530. in_buffer_length = len;
  531. continuation_buffer = NULL;
  532. }else{
  533. // Message have been fully processed (or ignored). Move pointer ahead
  534. // and continue with next message, if any.
  535. in_buffer_length -= message_length;
  536. in_buffer += message_length;
  537. }
  538. if(in_buffer_length > 0)
  539. {
  540. NODE_DBG("Get another published message\r\n");
  541. goto READPACKET;
  542. }
  543. break;
  544. }
  545. RX_PACKET_FINISHED:
  546. if(temp_pdata != NULL) {
  547. free(temp_pdata);
  548. }
  549. mqtt_send_if_possible(mud);
  550. NODE_DBG("leave mqtt_socket_received\n");
  551. return;
  552. }
  553. static void mqtt_socket_sent(void *arg)
  554. {
  555. NODE_DBG("enter mqtt_socket_sent.\n");
  556. lmqtt_userdata *mud = arg;
  557. if(mud == NULL)
  558. return;
  559. if(!mud->connected)
  560. return;
  561. mud->sending = false;
  562. os_timer_disarm(&mud->mqttTimer);
  563. if(mud->connState == MQTT_CONNECT_SENDING){
  564. mud->connState = MQTT_CONNECT_SENT;
  565. os_timer_arm(&mud->mqttTimer, MQTT_SEND_TIMEOUT * 1000, 0);
  566. // MQTT_CONNECT not queued.
  567. return;
  568. }
  569. /* Ready for timeout */
  570. os_timer_arm(&mud->mqttTimer, mud->conf.keepalive * 1000, 0);
  571. NODE_DBG("sent1, queue size: %d\n", msg_size(&(mud->mqtt_state.pending_msg_q)));
  572. msg_queue_t *node = msg_peek(&(mud->mqtt_state.pending_msg_q));
  573. if (node) {
  574. switch (node->msg_type) {
  575. case MQTT_MSG_TYPE_PUBLISH:
  576. // qos = 0, publish and forget. Run the callback now because we
  577. // won't get a puback from the server and it's not clear when else
  578. // we should tell the user the message drained from the egress queue
  579. if (node->publish_qos == 0) {
  580. msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q)));
  581. mqtt_socket_cb_lua_noarg(lua_getstate(), mud, mud->cb_puback_ref);
  582. mqtt_send_if_possible(mud);
  583. }
  584. break;
  585. case MQTT_MSG_TYPE_PUBACK:
  586. /* FALLTHROUGH */
  587. case MQTT_MSG_TYPE_PUBCOMP:
  588. /* FALLTHROUGH */
  589. case MQTT_MSG_TYPE_PINGREQ:
  590. msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q)));
  591. mqtt_send_if_possible(mud);
  592. break;
  593. case MQTT_MSG_TYPE_DISCONNECT:
  594. msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q)));
  595. mqtt_socket_do_disconnect(mud);
  596. break;
  597. }
  598. }
  599. NODE_DBG("sent2, queue size: %d\n", msg_size(&(mud->mqtt_state.pending_msg_q)));
  600. NODE_DBG("leave mqtt_socket_sent.\n");
  601. }
  602. static void mqtt_socket_connected(void *arg)
  603. {
  604. NODE_DBG("enter mqtt_socket_connected.\n");
  605. lmqtt_userdata *mud = arg;
  606. if(mud == NULL)
  607. return;
  608. struct espconn *pesp_conn = &mud->pesp_conn;
  609. mud->connected = true;
  610. espconn_regist_recvcb(pesp_conn, mqtt_socket_received);
  611. espconn_regist_sentcb(pesp_conn, mqtt_socket_sent);
  612. espconn_regist_disconcb(pesp_conn, mqtt_socket_disconnected);
  613. uint8_t temp_buffer[MQTT_BUF_SIZE];
  614. mqtt_message_buffer_t msgb;
  615. mqtt_msg_init(&msgb, temp_buffer, MQTT_BUF_SIZE);
  616. /* Build the mqtt_connect_info on the stack and assemble the message */
  617. lua_State *L = lua_getstate();
  618. int ltop = lua_gettop(L);
  619. struct mqtt_connect_info mci;
  620. mci.clean_session = mud->conf.flags.clean_session;
  621. mci.will_retain = mud->conf.flags.will_retain;
  622. mci.will_qos = mud->conf.flags.will_qos;
  623. mci.keepalive = mud->conf.keepalive;
  624. lua_rawgeti(L, LUA_REGISTRYINDEX, mud->conf.client_id_ref);
  625. mci.client_id = lua_tostring(L, -1);
  626. lua_rawgeti(L, LUA_REGISTRYINDEX, mud->conf.username_ref);
  627. mci.username = lua_tostring(L, -1);
  628. lua_rawgeti(L, LUA_REGISTRYINDEX, mud->conf.password_ref);
  629. mci.password = lua_tostring(L, -1);
  630. lua_rawgeti(L, LUA_REGISTRYINDEX, mud->conf.will_topic_ref);
  631. mci.will_topic = lua_tostring(L, -1);
  632. lua_rawgeti(L, LUA_REGISTRYINDEX, mud->conf.will_message_ref);
  633. mci.will_message = lua_tostring(L, -1);
  634. mqtt_message_t* temp_msg = mqtt_msg_connect(&msgb, &mci);
  635. NODE_DBG("Send MQTT connection infomation, data len: %d, d[0]=%d \r\n", temp_msg->length, temp_msg->data[0]);
  636. lua_settop(L, ltop); /* Done with strings, restore the stack */
  637. // not queue this message. should send right now. or should enqueue this before head.
  638. #ifdef CLIENT_SSL_ENABLE
  639. if(mud->conf.flags.secure)
  640. {
  641. espconn_secure_send(pesp_conn, temp_msg->data, temp_msg->length);
  642. }
  643. else
  644. #endif
  645. {
  646. espconn_send(pesp_conn, temp_msg->data, temp_msg->length);
  647. }
  648. mud->sending = true;
  649. os_timer_disarm(&mud->mqttTimer);
  650. os_timer_arm(&mud->mqttTimer, MQTT_SEND_TIMEOUT * 1000, 0);
  651. mud->connState = MQTT_CONNECT_SENDING;
  652. NODE_DBG("leave mqtt_socket_connected, heap = %u.\n", system_get_free_heap_size());
  653. return;
  654. }
  655. void mqtt_socket_timer(void *arg)
  656. {
  657. NODE_DBG("enter mqtt_socket_timer.\n");
  658. lmqtt_userdata *mud = (lmqtt_userdata*) arg;
  659. if(mud == NULL)
  660. return;
  661. if(mud->pesp_conn.proto.tcp == NULL){
  662. NODE_DBG("MQTT not connected\n");
  663. return;
  664. }
  665. NODE_DBG("timer, queue size: %d\n", msg_size(&(mud->mqtt_state.pending_msg_q)));
  666. if(mud->connState == MQTT_CONNECT_SENDING){ // MQTT_CONNECT send time out.
  667. NODE_DBG("sSend MQTT_CONNECT failed.\n");
  668. mud->connState = MQTT_INIT;
  669. mqtt_socket_do_disconnect(mud);
  670. mqtt_connack_fail(mud, MQTT_CONN_FAIL_TIMEOUT_SENDING);
  671. } else if(mud->connState == MQTT_CONNECT_SENT) { // wait for CONACK time out.
  672. NODE_DBG("MQTT_CONNECT timeout.\n");
  673. mud->connState = MQTT_INIT;
  674. mqtt_socket_do_disconnect(mud);
  675. mqtt_connack_fail(mud, MQTT_CONN_FAIL_TIMEOUT_RECEIVING);
  676. } else if(mud->connState == MQTT_DATA){
  677. if(!msg_peek(&(mud->mqtt_state.pending_msg_q))) {
  678. // no queued event.
  679. if (mud->keepalive_sent) {
  680. // Oh dear -- keepalive timer expired and still no ack of previous message
  681. mqtt_socket_do_disconnect(mud);
  682. } else {
  683. uint8_t temp_buffer[MQTT_BUF_SIZE];
  684. mqtt_message_buffer_t msgb;
  685. mqtt_msg_init(&msgb, temp_buffer, MQTT_BUF_SIZE);
  686. NODE_DBG("\r\nMQTT: Send keepalive packet\r\n");
  687. mqtt_message_t* temp_msg = mqtt_msg_pingreq(&msgb);
  688. msg_queue_t *node = msg_enqueue( &(mud->mqtt_state.pending_msg_q), temp_msg,
  689. 0, MQTT_MSG_TYPE_PINGREQ, (int)mqtt_get_qos(temp_msg->data) );
  690. mud->keepalive_sent = 1;
  691. mqtt_send_if_possible(mud);
  692. }
  693. }
  694. }
  695. NODE_DBG("leave mqtt_socket_timer.\n");
  696. }
  697. // Lua: mqtt.Client(clientid, keepalive, user, pass, clean_session, max_message_length)
  698. static int mqtt_socket_client( lua_State* L )
  699. {
  700. NODE_DBG("enter mqtt_socket_client.\n");
  701. lmqtt_userdata *mud;
  702. int stack = 1;
  703. int top = lua_gettop(L);
  704. // create a object
  705. mud = (lmqtt_userdata *)lua_newuserdata(L, sizeof(lmqtt_userdata));
  706. memset(mud, 0, sizeof(*mud));
  707. // pre-initialize it, in case of errors
  708. mud->self_ref = LUA_NOREF;
  709. mud->cb_connect_ref = LUA_NOREF;
  710. mud->cb_connect_fail_ref = LUA_NOREF;
  711. mud->cb_disconnect_ref = LUA_NOREF;
  712. mud->cb_message_ref = LUA_NOREF;
  713. mud->cb_overflow_ref = LUA_NOREF;
  714. mud->cb_suback_ref = LUA_NOREF;
  715. mud->cb_unsuback_ref = LUA_NOREF;
  716. mud->cb_puback_ref = LUA_NOREF;
  717. mud->conf.client_id_ref = LUA_NOREF;
  718. mud->conf.username_ref = LUA_NOREF;
  719. mud->conf.password_ref = LUA_NOREF;
  720. mud->conf.will_topic_ref = LUA_NOREF;
  721. mud->conf.will_message_ref = LUA_NOREF;
  722. mud->connState = MQTT_INIT;
  723. // set its metatable
  724. luaL_getmetatable(L, "mqtt.socket");
  725. lua_setmetatable(L, -2);
  726. if( lua_isstring(L,stack) ) // deal with the clientid string
  727. {
  728. lua_pushvalue(L, stack);
  729. stack++;
  730. } else {
  731. char tempid[20] = {0};
  732. sprintf(tempid, "%s%x", "NodeMCU_", system_get_chip_id() );
  733. lua_pushstring(L, tempid);
  734. }
  735. mud->conf.client_id_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  736. if(lua_isnumber( L, stack ))
  737. {
  738. mud->conf.keepalive = luaL_checkinteger( L, stack);
  739. stack++;
  740. }
  741. if(mud->conf.keepalive == 0) {
  742. mud->conf.keepalive = MQTT_DEFAULT_KEEPALIVE;
  743. }
  744. if(lua_isstring( L, stack )){
  745. lua_pushvalue(L, stack);
  746. mud->conf.username_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  747. stack++;
  748. }
  749. if(lua_isstring( L, stack )){
  750. lua_pushvalue(L, stack);
  751. mud->conf.password_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  752. stack++;
  753. }
  754. if(lua_isnumber( L, stack ))
  755. {
  756. mud->conf.flags.clean_session = !!luaL_checkinteger(L, stack);
  757. stack++;
  758. }
  759. if(lua_isnumber( L, stack ))
  760. {
  761. mud->conf.max_message_length = luaL_checkinteger( L, stack);
  762. stack++;
  763. }
  764. if(mud->conf.max_message_length == 0) {
  765. mud->conf.max_message_length = DEFAULT_MAX_MESSAGE_LENGTH;
  766. }
  767. mud->mqtt_state.pending_msg_q = NULL;
  768. mud->mqtt_state.recv_buffer = NULL;
  769. mud->mqtt_state.recv_buffer_size = 0;
  770. mud->mqtt_state.recv_buffer_state = MQTT_RECV_NORMAL;
  771. NODE_DBG("leave mqtt_socket_client.\n");
  772. return 1;
  773. }
  774. // Lua: mqtt.delete( socket )
  775. // call close() first
  776. // socket: unref everything
  777. static int mqtt_delete( lua_State* L )
  778. {
  779. NODE_DBG("enter mqtt_delete.\n");
  780. lmqtt_userdata *mud = (lmqtt_userdata *)luaL_checkudata(L, 1, "mqtt.socket");
  781. os_timer_disarm(&mud->mqttTimer);
  782. mud->connected = false;
  783. // ---- alloc-ed in mqtt_socket_connect()
  784. if(mud->pesp_conn.proto.tcp)
  785. free(mud->pesp_conn.proto.tcp);
  786. mud->pesp_conn.proto.tcp = NULL;
  787. while(mud->mqtt_state.pending_msg_q) {
  788. msg_destroy(msg_dequeue(&(mud->mqtt_state.pending_msg_q)));
  789. }
  790. //--------- alloc-ed in mqtt_socket_received()
  791. if(mud->mqtt_state.recv_buffer) {
  792. free(mud->mqtt_state.recv_buffer);
  793. mud->mqtt_state.recv_buffer = NULL;
  794. }
  795. // ----
  796. // free (unref) callback ref
  797. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_connect_ref);
  798. mud->cb_connect_ref = LUA_NOREF;
  799. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_connect_fail_ref);
  800. mud->cb_connect_fail_ref = LUA_NOREF;
  801. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_disconnect_ref);
  802. mud->cb_disconnect_ref = LUA_NOREF;
  803. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_message_ref);
  804. mud->cb_message_ref = LUA_NOREF;
  805. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_overflow_ref);
  806. mud->cb_overflow_ref = LUA_NOREF;
  807. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_suback_ref);
  808. mud->cb_suback_ref = LUA_NOREF;
  809. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_unsuback_ref);
  810. mud->cb_unsuback_ref = LUA_NOREF;
  811. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_puback_ref);
  812. mud->cb_puback_ref = LUA_NOREF;
  813. luaL_unref(L, LUA_REGISTRYINDEX, mud->conf.client_id_ref);
  814. mud->conf.client_id_ref = LUA_NOREF;
  815. luaL_unref(L, LUA_REGISTRYINDEX, mud->conf.username_ref);
  816. mud->conf.username_ref = LUA_NOREF;
  817. luaL_unref(L, LUA_REGISTRYINDEX, mud->conf.password_ref);
  818. mud->conf.password_ref = LUA_NOREF;
  819. luaL_unref(L, LUA_REGISTRYINDEX, mud->conf.will_topic_ref);
  820. mud->conf.will_topic_ref = LUA_NOREF;
  821. luaL_unref(L, LUA_REGISTRYINDEX, mud->conf.will_message_ref);
  822. mud->conf.will_message_ref = LUA_NOREF;
  823. int selfref = mud->self_ref;
  824. mud->self_ref = LUA_NOREF;
  825. luaL_unref(L, LUA_REGISTRYINDEX, mud->self_ref);
  826. NODE_DBG("leave mqtt_delete.\n");
  827. return 0;
  828. }
  829. static sint8 mqtt_socket_do_connect(struct lmqtt_userdata *mud)
  830. {
  831. NODE_DBG("enter mqtt_socket_do_connect.\n");
  832. sint8 espconn_status;
  833. mud->connState = MQTT_INIT;
  834. #ifdef CLIENT_SSL_ENABLE
  835. if(mud->conf.flags.secure)
  836. {
  837. NODE_DBG("mqtt_socket_do_connect using espconn_secure\n");
  838. espconn_status = espconn_secure_connect(&mud->pesp_conn);
  839. }
  840. else
  841. #endif
  842. {
  843. espconn_status = espconn_connect(&mud->pesp_conn);
  844. }
  845. NODE_DBG("leave mqtt_socket_do_connect espconn_status=%d\n", espconn_status);
  846. return espconn_status;
  847. }
  848. static void socket_dns_found(const char *name, ip_addr_t *ipaddr, void *arg)
  849. {
  850. lmqtt_userdata *mud = arg;
  851. if((ipaddr == NULL) || (ipaddr->addr == 0))
  852. {
  853. NODE_DBG("socket_dns_found failure\n");
  854. mqtt_connack_fail(mud, MQTT_CONN_FAIL_DNS);
  855. // although not connected, but fire disconnect callback to release every thing.
  856. mqtt_socket_disconnected(arg);
  857. return;
  858. }
  859. memcpy(&mud->pesp_conn.proto.tcp->remote_ip, &(ipaddr->addr), 4);
  860. NODE_DBG("socket_dns_found success: ");
  861. NODE_DBG(IPSTR, IP2STR(&(ipaddr->addr)));
  862. NODE_DBG("\n");
  863. if(mqtt_socket_do_connect(mud) != ESPCONN_OK) {
  864. NODE_DBG("socket_dns_found, got DNS but connect failed\n");
  865. mqtt_connack_fail(mud, MQTT_CONN_FAIL_DNS);
  866. mqtt_socket_disconnected(arg);
  867. return;
  868. }
  869. }
  870. #include "pm/swtimer.h"
  871. // Lua: mqtt:connect( host, port, secure, function(client), function(client, connect_return_code) )
  872. static int mqtt_socket_connect( lua_State* L )
  873. {
  874. NODE_DBG("enter mqtt_socket_connect.\n");
  875. lmqtt_userdata *mud = NULL;
  876. unsigned port = 1883;
  877. size_t il;
  878. ip_addr_t ipaddr;
  879. const char *domain;
  880. int stack = 1;
  881. int top = lua_gettop(L);
  882. mud = (lmqtt_userdata *)luaL_checkudata(L, stack, "mqtt.socket");
  883. stack++;
  884. struct espconn *pesp_conn = &mud->pesp_conn;
  885. if(mud->connected){
  886. return luaL_error(L, "already connected");
  887. }
  888. mud->connected = false;
  889. mud->sending = false;
  890. if( (stack<=top) && lua_isstring(L,stack) ) // deal with the domain string
  891. {
  892. domain = luaL_checklstring( L, stack, &il );
  893. if (!domain)
  894. return luaL_error(L, "invalid domain");
  895. stack++;
  896. }
  897. if ( (stack<=top) && lua_isnumber(L, stack) )
  898. {
  899. port = lua_tointeger(L, stack);
  900. stack++;
  901. }
  902. if ( (stack<=top) && (lua_isnumber(L, stack) || lua_isboolean(L, stack)) )
  903. {
  904. if (lua_isnumber(L, stack)) {
  905. platform_print_deprecation_note("mqtt.connect secure parameter as integer","in the future");
  906. mud->conf.flags.secure = !!lua_tointeger(L, stack);
  907. } else {
  908. mud->conf.flags.secure = lua_toboolean(L, stack);
  909. }
  910. stack++;
  911. }
  912. #ifndef CLIENT_SSL_ENABLE
  913. if ( mud->conf.flags.secure )
  914. {
  915. return luaL_error(L, "ssl not available");
  916. }
  917. #endif
  918. // call back function when a connection is obtained, tcp only
  919. if ((stack<=top) && (lua_isfunction(L, stack))){
  920. lua_pushvalue(L, stack); // copy argument (func) to the top of stack
  921. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_connect_ref);
  922. mud->cb_connect_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  923. }
  924. stack++;
  925. // call back function when a connection fails
  926. if ((stack<=top) && (lua_isfunction(L, stack))){
  927. lua_pushvalue(L, stack); // copy argument (func) to the top of stack
  928. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_connect_fail_ref);
  929. mud->cb_connect_fail_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  930. }
  931. if (!pesp_conn->proto.tcp)
  932. pesp_conn->proto.tcp = (esp_tcp *)calloc(1,sizeof(esp_tcp));
  933. if(!pesp_conn->proto.tcp) {
  934. return luaL_error(L, "not enough memory");
  935. }
  936. luaL_unref(L, LUA_REGISTRYINDEX, mud->self_ref);
  937. lua_pushvalue(L, 1); // copy userdata and persist it in the registry
  938. mud->self_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  939. pesp_conn->type = ESPCONN_TCP;
  940. pesp_conn->state = ESPCONN_NONE;
  941. pesp_conn->proto.tcp->remote_port = port;
  942. if (pesp_conn->proto.tcp->local_port == 0)
  943. pesp_conn->proto.tcp->local_port = espconn_port();
  944. espconn_regist_connectcb(pesp_conn, mqtt_socket_connected);
  945. espconn_regist_reconcb(pesp_conn, mqtt_socket_reconnected);
  946. os_timer_disarm(&mud->mqttTimer);
  947. os_timer_setfn(&mud->mqttTimer, (os_timer_func_t *)mqtt_socket_timer, mud);
  948. SWTIMER_REG_CB(mqtt_socket_timer, SWTIMER_RESUME);
  949. //I assume that mqtt_socket_timer connects to the mqtt server, but I'm not really sure what impact light_sleep will have on it.
  950. //My guess: If in doubt, resume the timer
  951. // timer started in socket_connect()
  952. ip_addr_t host_ip;
  953. switch (dns_gethostbyname(domain, &host_ip, socket_dns_found, mud))
  954. {
  955. case ERR_OK:
  956. socket_dns_found(domain, &host_ip, mud); // ip is returned in host_ip.
  957. break;
  958. case ERR_INPROGRESS:
  959. break;
  960. default:
  961. // Something has gone wrong; bail out?
  962. mqtt_connack_fail(mud, MQTT_CONN_FAIL_DNS);
  963. }
  964. NODE_DBG("leave mqtt_socket_connect.\n");
  965. return 0;
  966. }
  967. // Lua: mqtt:close()
  968. // client disconnect and unref itself
  969. static int mqtt_socket_close( lua_State* L )
  970. {
  971. NODE_DBG("enter mqtt_socket_close.\n");
  972. lmqtt_userdata *mud = NULL;
  973. mud = (lmqtt_userdata *)luaL_checkudata(L, 1, "mqtt.socket");
  974. sint8 espconn_status = 0;
  975. if (mud->connected) {
  976. uint8_t temp_buffer[MQTT_BUF_SIZE];
  977. mqtt_message_buffer_t msgb;
  978. mqtt_msg_init(&msgb, temp_buffer, MQTT_BUF_SIZE);
  979. // Send disconnect message
  980. mqtt_message_t* temp_msg = mqtt_msg_disconnect(&msgb);
  981. NODE_DBG("Send MQTT disconnect infomation, data len: %d, d[0]=%d \r\n", temp_msg->length, temp_msg->data[0]);
  982. if (!msg_enqueue(&(mud->mqtt_state.pending_msg_q), temp_msg, 0,
  983. MQTT_MSG_TYPE_DISCONNECT, 0))
  984. goto err;
  985. mqtt_send_if_possible(mud);
  986. }
  987. NODE_DBG("leave mqtt_socket_close.\n");
  988. return 0;
  989. err:
  990. /* OOM while trying to build the disconnect message. Fail the connection */
  991. mqtt_socket_do_disconnect(mud);
  992. NODE_DBG("leave mqtt_socket_close on error path\n");
  993. return 0;
  994. }
  995. // Lua: mqtt:on( "method", function() )
  996. static int mqtt_socket_on( lua_State* L )
  997. {
  998. NODE_DBG("enter mqtt_socket_on.\n");
  999. lmqtt_userdata *mud;
  1000. size_t sl;
  1001. mud = (lmqtt_userdata *)luaL_checkudata(L, 1, "mqtt.socket");
  1002. luaL_checktype(L, 3, LUA_TFUNCTION);
  1003. lua_pushvalue(L, 3); // copy argument (func) to the top of stack
  1004. static const char * const cbnames[] = {
  1005. "connect", "connfail", "offline",
  1006. "message", "overflow",
  1007. "puback", "suback", "unsuback",
  1008. NULL
  1009. };
  1010. switch (luaL_checkoption(L, 2, NULL, cbnames)) {
  1011. case 0:
  1012. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_connect_ref);
  1013. mud->cb_connect_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  1014. break;
  1015. case 1:
  1016. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_connect_fail_ref);
  1017. mud->cb_connect_fail_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  1018. break;
  1019. case 2:
  1020. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_disconnect_ref);
  1021. mud->cb_disconnect_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  1022. break;
  1023. case 3:
  1024. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_message_ref);
  1025. mud->cb_message_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  1026. break;
  1027. case 4:
  1028. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_overflow_ref);
  1029. mud->cb_overflow_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  1030. break;
  1031. case 5:
  1032. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_puback_ref);
  1033. mud->cb_puback_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  1034. break;
  1035. case 6:
  1036. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_suback_ref);
  1037. mud->cb_suback_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  1038. break;
  1039. case 7:
  1040. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_unsuback_ref);
  1041. mud->cb_unsuback_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  1042. break;
  1043. }
  1044. NODE_DBG("leave mqtt_socket_on.\n");
  1045. return 0;
  1046. }
  1047. // Lua: bool = mqtt:unsubscribe(topic, function())
  1048. static int mqtt_socket_unsubscribe( lua_State* L ) {
  1049. NODE_DBG("enter mqtt_socket_unsubscribe.\n");
  1050. uint8_t stack = 1;
  1051. uint16_t msg_id;
  1052. const char *topic;
  1053. size_t il;
  1054. lmqtt_userdata *mud;
  1055. mud = (lmqtt_userdata *) luaL_checkudata( L, stack, "mqtt.socket" );
  1056. stack++;
  1057. if(!mud->connected){
  1058. luaL_error( L, "not connected" );
  1059. lua_pushboolean(L, 0);
  1060. return 1;
  1061. }
  1062. uint8_t temp_buffer[MQTT_BUF_SIZE];
  1063. mqtt_message_buffer_t msgb;
  1064. mqtt_msg_init(&msgb, temp_buffer, MQTT_BUF_SIZE);
  1065. mqtt_message_t *temp_msg = NULL;
  1066. if( lua_istable( L, stack ) ) {
  1067. NODE_DBG("unsubscribe table\n");
  1068. lua_pushnil( L ); /* first key */
  1069. int topic_count = 0;
  1070. uint8_t overflow = 0;
  1071. while( lua_next( L, stack ) != 0 ) {
  1072. topic = luaL_checkstring( L, -2 );
  1073. if (topic_count == 0) {
  1074. msg_id = mqtt_next_message_id(mud);
  1075. temp_msg = mqtt_msg_unsubscribe_init( &msgb, msg_id );
  1076. }
  1077. temp_msg = mqtt_msg_unsubscribe_topic( &msgb, topic );
  1078. topic_count++;
  1079. NODE_DBG("topic: %s - length: %d\n", topic, temp_msg->length);
  1080. if (temp_msg->length == 0) {
  1081. lua_pop(L, 1);
  1082. overflow = 1;
  1083. break; // too long message for the outbuffer.
  1084. }
  1085. lua_pop( L, 1 );
  1086. }
  1087. if (topic_count == 0){
  1088. return luaL_error( L, "no topics found" );
  1089. }
  1090. if (overflow != 0){
  1091. return luaL_error( L, "buffer overflow, can't enqueue all unsubscriptions" );
  1092. }
  1093. temp_msg = mqtt_msg_unsubscribe_fini( &msgb );
  1094. if (temp_msg->length == 0) {
  1095. return luaL_error( L, "buffer overflow, can't enqueue all unsubscriptions" );
  1096. }
  1097. stack++;
  1098. } else {
  1099. NODE_DBG("unsubscribe string\n");
  1100. topic = luaL_checklstring( L, stack, &il );
  1101. stack++;
  1102. if( topic == NULL ){
  1103. return luaL_error( L, "need topic name" );
  1104. }
  1105. msg_id = mqtt_next_message_id(mud);
  1106. temp_msg = mqtt_msg_unsubscribe( &msgb, topic, msg_id );
  1107. }
  1108. if (lua_isfunction(L, stack)) { // TODO: this will overwrite the previous one.
  1109. lua_pushvalue( L, stack ); // copy argument (func) to the top of stack
  1110. luaL_unref( L, LUA_REGISTRYINDEX, mud->cb_unsuback_ref );
  1111. mud->cb_unsuback_ref = luaL_ref( L, LUA_REGISTRYINDEX );
  1112. }
  1113. msg_queue_t *node = msg_enqueue( &(mud->mqtt_state.pending_msg_q), temp_msg,
  1114. msg_id, MQTT_MSG_TYPE_UNSUBSCRIBE, (int)mqtt_get_qos(temp_msg->data) );
  1115. NODE_DBG("topic: %s - id: %d - qos: %d, length: %d\n", topic, node->msg_id, node->publish_qos, node->msg.length);
  1116. NODE_DBG("msg_size: %d\n", msg_size(&(mud->mqtt_state.pending_msg_q)));
  1117. sint8 espconn_status = ESPCONN_IF;
  1118. espconn_status = mqtt_send_if_possible(mud);
  1119. if(!node || espconn_status != ESPCONN_OK){
  1120. lua_pushboolean(L, 0);
  1121. } else {
  1122. lua_pushboolean(L, 1); // enqueued succeed.
  1123. }
  1124. NODE_DBG("unsubscribe, queue size: %d\n", msg_size(&(mud->mqtt_state.pending_msg_q)));
  1125. NODE_DBG("leave mqtt_socket_unsubscribe.\n");
  1126. return 1;
  1127. }
  1128. // Lua: bool = mqtt:subscribe(topic, qos, function())
  1129. static int mqtt_socket_subscribe( lua_State* L ) {
  1130. NODE_DBG("enter mqtt_socket_subscribe.\n");
  1131. uint8_t stack = 1, qos = 0;
  1132. uint16_t msg_id;
  1133. const char *topic;
  1134. size_t il;
  1135. lmqtt_userdata *mud;
  1136. mud = (lmqtt_userdata *) luaL_checkudata( L, stack, "mqtt.socket" );
  1137. stack++;
  1138. if(!mud->connected){
  1139. luaL_error( L, "not connected" );
  1140. lua_pushboolean(L, 0);
  1141. return 1;
  1142. }
  1143. uint8_t temp_buffer[MQTT_BUF_SIZE];
  1144. mqtt_message_buffer_t msgb;
  1145. mqtt_msg_init(&msgb, temp_buffer, MQTT_BUF_SIZE);
  1146. mqtt_message_t *temp_msg = NULL;
  1147. if( lua_istable( L, stack ) ) {
  1148. NODE_DBG("subscribe table\n");
  1149. lua_pushnil( L ); /* first key */
  1150. int topic_count = 0;
  1151. uint8_t overflow = 0;
  1152. while( lua_next( L, stack ) != 0 ) {
  1153. topic = luaL_checkstring( L, -2 );
  1154. qos = luaL_checkinteger( L, -1 );
  1155. if (topic_count == 0) {
  1156. msg_id = mqtt_next_message_id(mud);
  1157. temp_msg = mqtt_msg_subscribe_init( &msgb, msg_id );
  1158. }
  1159. temp_msg = mqtt_msg_subscribe_topic( &msgb, topic, qos );
  1160. topic_count++;
  1161. NODE_DBG("topic: %s - qos: %d, length: %d\n", topic, qos, temp_msg->length);
  1162. if (temp_msg->length == 0) {
  1163. lua_pop(L, 1);
  1164. overflow = 1;
  1165. break; // too long message for the outbuffer.
  1166. }
  1167. lua_pop( L, 1 );
  1168. }
  1169. if (topic_count == 0){
  1170. return luaL_error( L, "no topics found" );
  1171. }
  1172. if (overflow != 0){
  1173. return luaL_error( L, "buffer overflow, can't enqueue all subscriptions" );
  1174. }
  1175. temp_msg = mqtt_msg_subscribe_fini( &msgb );
  1176. if (temp_msg->length == 0) {
  1177. return luaL_error( L, "buffer overflow, can't enqueue all subscriptions" );
  1178. }
  1179. stack++;
  1180. } else {
  1181. NODE_DBG("subscribe string\n");
  1182. topic = luaL_checklstring( L, stack, &il );
  1183. stack++;
  1184. if( topic == NULL ){
  1185. return luaL_error( L, "need topic name" );
  1186. }
  1187. qos = luaL_checkinteger( L, stack );
  1188. msg_id = mqtt_next_message_id(mud);
  1189. temp_msg = mqtt_msg_subscribe( &msgb, topic, qos, msg_id );
  1190. stack++;
  1191. }
  1192. if (lua_isfunction(L, stack)) { // TODO: this will overwrite the previous one.
  1193. lua_pushvalue( L, stack ); // copy argument (func) to the top of stack
  1194. luaL_unref( L, LUA_REGISTRYINDEX, mud->cb_suback_ref );
  1195. mud->cb_suback_ref = luaL_ref( L, LUA_REGISTRYINDEX );
  1196. }
  1197. msg_queue_t *node = msg_enqueue( &(mud->mqtt_state.pending_msg_q), temp_msg,
  1198. msg_id, MQTT_MSG_TYPE_SUBSCRIBE, (int)mqtt_get_qos(temp_msg->data) );
  1199. NODE_DBG("topic: %s - id: %d - qos: %d, length: %d\n", topic, node->msg_id, node->publish_qos, node->msg.length);
  1200. NODE_DBG("msg_size: %d\n", msg_size(&(mud->mqtt_state.pending_msg_q)));
  1201. sint8 espconn_status = ESPCONN_IF;
  1202. espconn_status = mqtt_send_if_possible(mud);
  1203. if(!node || espconn_status != ESPCONN_OK){
  1204. lua_pushboolean(L, 0);
  1205. } else {
  1206. lua_pushboolean(L, 1); // enqueued succeed.
  1207. }
  1208. NODE_DBG("subscribe, queue size: %d\n", msg_size(&(mud->mqtt_state.pending_msg_q)));
  1209. NODE_DBG("leave mqtt_socket_subscribe.\n");
  1210. return 1;
  1211. }
  1212. // Lua: bool = mqtt:publish( topic, payload, qos, retain, function() )
  1213. static int mqtt_socket_publish( lua_State* L )
  1214. {
  1215. NODE_DBG("enter mqtt_socket_publish.\n");
  1216. lmqtt_userdata *mud;
  1217. size_t l;
  1218. uint8_t stack = 1;
  1219. uint16_t msg_id = 0;
  1220. mud = (lmqtt_userdata *)luaL_checkudata(L, stack, "mqtt.socket");
  1221. stack++;
  1222. if(!mud->connected){
  1223. return luaL_error( L, "not connected" );
  1224. }
  1225. const char *topic = luaL_checklstring( L, stack, &l );
  1226. stack ++;
  1227. if (topic == NULL){
  1228. return luaL_error( L, "need topic" );
  1229. }
  1230. const char *payload = luaL_checklstring( L, stack, &l );
  1231. stack ++;
  1232. uint8_t qos = luaL_checkinteger( L, stack);
  1233. stack ++;
  1234. uint8_t retain = luaL_checkinteger( L, stack);
  1235. stack ++;
  1236. if (qos != 0) {
  1237. msg_id = mqtt_next_message_id(mud);
  1238. }
  1239. uint8_t temp_buffer[MQTT_BUF_SIZE];
  1240. mqtt_message_buffer_t msgb;
  1241. mqtt_msg_init(&msgb, temp_buffer, MQTT_BUF_SIZE);
  1242. mqtt_message_t *temp_msg = mqtt_msg_publish(&msgb,
  1243. topic, payload, l,
  1244. qos, retain,
  1245. msg_id);
  1246. if (lua_isfunction(L, stack)){
  1247. lua_pushvalue(L, stack); // copy argument (func) to the top of stack
  1248. luaL_unref(L, LUA_REGISTRYINDEX, mud->cb_puback_ref);
  1249. mud->cb_puback_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  1250. }
  1251. msg_queue_t *node = msg_enqueue(&(mud->mqtt_state.pending_msg_q), temp_msg,
  1252. msg_id, MQTT_MSG_TYPE_PUBLISH, (int)qos );
  1253. sint8 espconn_status = ESPCONN_OK;
  1254. espconn_status = mqtt_send_if_possible(mud);
  1255. if(!node || espconn_status != ESPCONN_OK){
  1256. lua_pushboolean(L, 0);
  1257. } else {
  1258. lua_pushboolean(L, 1); // enqueued succeed.
  1259. }
  1260. NODE_DBG("publish, queue size: %d\n", msg_size(&(mud->mqtt_state.pending_msg_q)));
  1261. NODE_DBG("leave mqtt_socket_publish.\n");
  1262. return 1;
  1263. }
  1264. // Lua: mqtt:lwt( topic, message, [qos, [retain]])
  1265. static int mqtt_socket_lwt( lua_State* L )
  1266. {
  1267. NODE_DBG("enter mqtt_socket_lwt.\n");
  1268. lmqtt_userdata *mud = luaL_checkudata( L, 1, "mqtt.socket" );
  1269. luaL_argcheck( L, lua_isstring(L, 2), 2, "need lwt topic");
  1270. luaL_argcheck( L, lua_isstring(L, 3), 3, "need lwt message");
  1271. lua_pushvalue(L, 2);
  1272. luaL_reref(L, LUA_REGISTRYINDEX, &mud->conf.will_topic_ref);
  1273. lua_pushvalue(L, 3);
  1274. luaL_reref(L, LUA_REGISTRYINDEX, &mud->conf.will_message_ref);
  1275. int stack = 4;
  1276. if ( lua_isnumber(L, stack) )
  1277. {
  1278. mud->conf.flags.will_qos = lua_tointeger(L, stack) & 0x3;
  1279. stack++;
  1280. }
  1281. if ( lua_isnumber(L, stack) )
  1282. {
  1283. mud->conf.flags.will_retain = !!lua_tointeger(L, stack);
  1284. stack++;
  1285. }
  1286. NODE_DBG("leave mqtt_socket_lwt.\n");
  1287. return 0;
  1288. }
  1289. // Module function map
  1290. LROT_BEGIN(mqtt_socket, NULL, LROT_MASK_GC_INDEX)
  1291. LROT_FUNCENTRY( __gc, mqtt_delete )
  1292. LROT_TABENTRY( __index, mqtt_socket )
  1293. LROT_FUNCENTRY( connect, mqtt_socket_connect )
  1294. LROT_FUNCENTRY( close, mqtt_socket_close )
  1295. LROT_FUNCENTRY( publish, mqtt_socket_publish )
  1296. LROT_FUNCENTRY( subscribe, mqtt_socket_subscribe )
  1297. LROT_FUNCENTRY( unsubscribe, mqtt_socket_unsubscribe )
  1298. LROT_FUNCENTRY( lwt, mqtt_socket_lwt )
  1299. LROT_FUNCENTRY( on, mqtt_socket_on )
  1300. LROT_END(mqtt_socket, NULL, LROT_MASK_GC_INDEX)
  1301. LROT_BEGIN(mqtt, NULL, 0)
  1302. LROT_FUNCENTRY( Client, mqtt_socket_client )
  1303. LROT_NUMENTRY( CONN_FAIL_SERVER_NOT_FOUND, MQTT_CONN_FAIL_SERVER_NOT_FOUND )
  1304. LROT_NUMENTRY( CONN_FAIL_NOT_A_CONNACK_MSG, MQTT_CONN_FAIL_NOT_A_CONNACK_MSG )
  1305. LROT_NUMENTRY( CONN_FAIL_DNS, MQTT_CONN_FAIL_DNS )
  1306. LROT_NUMENTRY( CONN_FAIL_TIMEOUT_RECEIVING, MQTT_CONN_FAIL_TIMEOUT_RECEIVING )
  1307. LROT_NUMENTRY( CONN_FAIL_TIMEOUT_SENDING, MQTT_CONN_FAIL_TIMEOUT_SENDING )
  1308. LROT_NUMENTRY( CONNACK_ACCEPTED, MQTT_CONNACK_ACCEPTED )
  1309. LROT_NUMENTRY( CONNACK_REFUSED_PROTOCOL_VER, MQTT_CONNACK_REFUSED_PROTOCOL_VER )
  1310. LROT_NUMENTRY( CONNACK_REFUSED_ID_REJECTED, MQTT_CONNACK_REFUSED_ID_REJECTED )
  1311. LROT_NUMENTRY( CONNACK_REFUSED_SERVER_UNAVAILABLE, MQTT_CONNACK_REFUSED_SERVER_UNAVAILABLE )
  1312. LROT_NUMENTRY( CONNACK_REFUSED_BAD_USER_OR_PASS, MQTT_CONNACK_REFUSED_BAD_USER_OR_PASS )
  1313. LROT_NUMENTRY( CONNACK_REFUSED_NOT_AUTHORIZED, MQTT_CONNACK_REFUSED_NOT_AUTHORIZED )
  1314. LROT_END(mqtt, NULL, 0)
  1315. int luaopen_mqtt( lua_State *L )
  1316. {
  1317. luaL_rometatable(L, "mqtt.socket", LROT_TABLEREF(mqtt_socket));
  1318. return 0;
  1319. }
  1320. NODEMCU_MODULE(MQTT, "mqtt", mqtt, luaopen_mqtt);