net.c 31 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061
  1. // Module for network
  2. #include "module.h"
  3. #include "lauxlib.h"
  4. #include "platform.h"
  5. #include "lmem.h"
  6. #include <string.h>
  7. #include <strings.h>
  8. #include <stddef.h>
  9. #include <stdint.h>
  10. #include "mem.h"
  11. #include "osapi.h"
  12. #include "lwip/err.h"
  13. #include "lwip/ip_addr.h"
  14. #include "lwip/dns.h"
  15. #include "lwip/igmp.h"
  16. #include "lwip/tcp.h"
  17. #include "lwip/udp.h"
  18. #if defined(CLIENT_SSL_ENABLE) && defined(LUA_USE_MODULES_NET) && defined(LUA_USE_MODULES_TLS)
  19. #define TLS_MODULE_PRESENT
  20. #endif
  21. typedef enum net_type {
  22. TYPE_TCP_SERVER = 0,
  23. TYPE_TCP_CLIENT,
  24. TYPE_UDP_SOCKET
  25. } net_type;
  26. typedef const char net_table_name[14];
  27. static const net_table_name NET_TABLES[] = {
  28. "net.tcpserver",
  29. "net.tcpsocket",
  30. "net.udpsocket"
  31. };
  32. #define NET_TABLE_TCP_SERVER NET_TABLES[0]
  33. #define NET_TABLE_TCP_CLIENT NET_TABLES[1]
  34. #define NET_TABLE_UDP_SOCKET NET_TABLES[2]
  35. #define TYPE_TCP TYPE_TCP_CLIENT
  36. #define TYPE_UDP TYPE_UDP_SOCKET
  37. typedef struct lnet_userdata {
  38. enum net_type type;
  39. int self_ref;
  40. union {
  41. struct tcp_pcb *tcp_pcb;
  42. struct udp_pcb *udp_pcb;
  43. void *pcb;
  44. };
  45. union {
  46. struct {
  47. int cb_accept_ref;
  48. int timeout;
  49. } server;
  50. struct {
  51. int wait_dns;
  52. int cb_dns_ref;
  53. int cb_receive_ref;
  54. int cb_sent_ref;
  55. // Only for TCP:
  56. int hold;
  57. int cb_connect_ref;
  58. int cb_disconnect_ref;
  59. int cb_reconnect_ref;
  60. } client;
  61. };
  62. } lnet_userdata;
  63. #pragma mark - LWIP errors
  64. int lwip_lua_checkerr (lua_State *L, err_t err) {
  65. switch (err) {
  66. case ERR_OK: return 0;
  67. case ERR_MEM: return luaL_error(L, "out of memory");
  68. case ERR_BUF: return luaL_error(L, "buffer error");
  69. case ERR_TIMEOUT: return luaL_error(L, "timeout");
  70. case ERR_RTE: return luaL_error(L, "routing problem");
  71. case ERR_INPROGRESS: return luaL_error(L, "in progress");
  72. case ERR_VAL: return luaL_error(L, "illegal value");
  73. case ERR_WOULDBLOCK: return luaL_error(L, "would block");
  74. case ERR_ABRT: return luaL_error(L, "connection aborted");
  75. case ERR_RST: return luaL_error(L, "connection reset");
  76. case ERR_CLSD: return luaL_error(L, "connection closed");
  77. case ERR_CONN: return luaL_error(L, "not connected");
  78. case ERR_ARG: return luaL_error(L, "illegal argument");
  79. case ERR_USE: return luaL_error(L, "address in use");
  80. case ERR_IF: return luaL_error(L, "netif error");
  81. case ERR_ISCONN: return luaL_error(L, "already connected");
  82. default: return luaL_error(L, "unknown error");
  83. }
  84. }
  85. #pragma mark - Create
  86. lnet_userdata *net_create( lua_State *L, enum net_type type ) {
  87. const char *mt = NET_TABLES[type];
  88. lnet_userdata *ud = (lnet_userdata *)lua_newuserdata(L, sizeof(lnet_userdata));
  89. if (!ud) return NULL;
  90. luaL_getmetatable(L, mt);
  91. lua_setmetatable(L, -2);
  92. ud->type = type;
  93. ud->self_ref = LUA_NOREF;
  94. ud->pcb = NULL;
  95. switch (type) {
  96. case TYPE_TCP_CLIENT:
  97. ud->client.cb_connect_ref = LUA_NOREF;
  98. ud->client.cb_reconnect_ref = LUA_NOREF;
  99. ud->client.cb_disconnect_ref = LUA_NOREF;
  100. ud->client.hold = 0;
  101. case TYPE_UDP_SOCKET:
  102. ud->client.wait_dns = 0;
  103. ud->client.cb_dns_ref = LUA_NOREF;
  104. ud->client.cb_receive_ref = LUA_NOREF;
  105. ud->client.cb_sent_ref = LUA_NOREF;
  106. break;
  107. case TYPE_TCP_SERVER:
  108. ud->server.cb_accept_ref = LUA_NOREF;
  109. break;
  110. }
  111. return ud;
  112. }
  113. #pragma mark - LWIP callbacks
  114. static void net_err_cb(void *arg, err_t err) {
  115. lnet_userdata *ud = (lnet_userdata*)arg;
  116. if (!ud || ud->type != TYPE_TCP_CLIENT || ud->self_ref == LUA_NOREF) return;
  117. ud->pcb = NULL; // Will be freed at LWIP level
  118. lua_State *L = lua_getstate();
  119. int ref;
  120. if (err != ERR_OK && ud->client.cb_reconnect_ref != LUA_NOREF)
  121. ref = ud->client.cb_reconnect_ref;
  122. else ref = ud->client.cb_disconnect_ref;
  123. if (ref != LUA_NOREF) {
  124. lua_rawgeti(L, LUA_REGISTRYINDEX, ref);
  125. lua_rawgeti(L, LUA_REGISTRYINDEX, ud->self_ref);
  126. lua_pushinteger(L, err);
  127. lua_call(L, 2, 0);
  128. }
  129. if (ud->client.wait_dns == 0) {
  130. lua_gc(L, LUA_GCSTOP, 0);
  131. luaL_unref(L, LUA_REGISTRYINDEX, ud->self_ref);
  132. ud->self_ref = LUA_NOREF;
  133. lua_gc(L, LUA_GCRESTART, 0);
  134. }
  135. }
  136. static err_t net_connected_cb(void *arg, struct tcp_pcb *tpcb, err_t err) {
  137. lnet_userdata *ud = (lnet_userdata*)arg;
  138. if (!ud || ud->pcb != tpcb) return ERR_ABRT;
  139. if (err != ERR_OK) {
  140. net_err_cb(arg, err);
  141. return ERR_ABRT;
  142. }
  143. lua_State *L = lua_getstate();
  144. if (ud->self_ref != LUA_NOREF && ud->client.cb_connect_ref != LUA_NOREF) {
  145. lua_rawgeti(L, LUA_REGISTRYINDEX, ud->client.cb_connect_ref);
  146. lua_rawgeti(L, LUA_REGISTRYINDEX, ud->self_ref);
  147. lua_call(L, 1, 0);
  148. }
  149. return ERR_OK;
  150. }
  151. static void net_dns_cb(const char *name, ip_addr_t *ipaddr, void *arg) {
  152. ip_addr_t addr;
  153. if (ipaddr != NULL) addr = *ipaddr;
  154. else addr.addr = 0xFFFFFFFF;
  155. lnet_userdata *ud = (lnet_userdata*)arg;
  156. if (!ud) return;
  157. lua_State *L = lua_getstate();
  158. if (ud->self_ref != LUA_NOREF && ud->client.cb_dns_ref != LUA_NOREF) {
  159. lua_rawgeti(L, LUA_REGISTRYINDEX, ud->client.cb_dns_ref);
  160. lua_rawgeti(L, LUA_REGISTRYINDEX, ud->self_ref);
  161. if (addr.addr != 0xFFFFFFFF) {
  162. char iptmp[16];
  163. bzero(iptmp, 16);
  164. ets_sprintf(iptmp, IPSTR, IP2STR(&addr.addr));
  165. lua_pushstring(L, iptmp);
  166. } else {
  167. lua_pushnil(L);
  168. }
  169. lua_call(L, 2, 0);
  170. }
  171. ud->client.wait_dns --;
  172. if (ud->pcb && ud->type == TYPE_TCP_CLIENT && ud->tcp_pcb->state == CLOSED) {
  173. tcp_connect(ud->tcp_pcb, &addr, ud->tcp_pcb->remote_port, net_connected_cb);
  174. } else if (!ud->pcb && ud->client.wait_dns == 0) {
  175. lua_gc(L, LUA_GCSTOP, 0);
  176. luaL_unref(L, LUA_REGISTRYINDEX, ud->self_ref);
  177. ud->self_ref = LUA_NOREF;
  178. lua_gc(L, LUA_GCRESTART, 0);
  179. }
  180. }
  181. static void net_recv_cb(lnet_userdata *ud, struct pbuf *p, ip_addr_t *addr, u16_t port) {
  182. if (ud->client.cb_receive_ref == LUA_NOREF) {
  183. pbuf_free(p);
  184. return;
  185. }
  186. int num_args = 2;
  187. char iptmp[16] = { 0, };
  188. if (ud->type == TYPE_UDP_SOCKET)
  189. {
  190. num_args += 2;
  191. ets_sprintf(iptmp, IPSTR, IP2STR(&addr->addr));
  192. }
  193. lua_State *L = lua_getstate();
  194. struct pbuf *pp = p;
  195. while (pp)
  196. {
  197. lua_rawgeti(L, LUA_REGISTRYINDEX, ud->client.cb_receive_ref);
  198. lua_rawgeti(L, LUA_REGISTRYINDEX, ud->self_ref);
  199. lua_pushlstring(L, pp->payload, pp->len);
  200. if (ud->type == TYPE_UDP_SOCKET) {
  201. lua_pushinteger(L, port);
  202. lua_pushstring(L, iptmp);
  203. }
  204. lua_call(L, num_args, 0);
  205. pp = pp->next;
  206. }
  207. pbuf_free(p);
  208. }
  209. static void net_udp_recv_cb(void *arg, struct udp_pcb *pcb, struct pbuf *p, ip_addr_t *addr, u16_t port) {
  210. lnet_userdata *ud = (lnet_userdata*)arg;
  211. if (!ud || !ud->pcb || ud->type != TYPE_UDP_SOCKET || ud->self_ref == LUA_NOREF) {
  212. if (p) pbuf_free(p);
  213. return;
  214. }
  215. net_recv_cb(ud, p, addr, port);
  216. }
  217. static err_t net_tcp_recv_cb(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) {
  218. lnet_userdata *ud = (lnet_userdata*)arg;
  219. if (!ud || !ud->pcb || ud->type != TYPE_TCP_CLIENT || ud->self_ref == LUA_NOREF)
  220. return ERR_ABRT;
  221. if (!p) {
  222. net_err_cb(arg, err);
  223. return tcp_close(tpcb);
  224. }
  225. net_recv_cb(ud, p, 0, 0);
  226. tcp_recved(tpcb, ud->client.hold ? 0 : TCP_WND);
  227. return ERR_OK;
  228. }
  229. static err_t net_sent_cb(void *arg, struct tcp_pcb *tpcb, u16_t len) {
  230. lnet_userdata *ud = (lnet_userdata*)arg;
  231. if (!ud || !ud->pcb || ud->type != TYPE_TCP_CLIENT || ud->self_ref == LUA_NOREF) return ERR_ABRT;
  232. if (ud->client.cb_sent_ref == LUA_NOREF) return ERR_OK;
  233. lua_State *L = lua_getstate();
  234. lua_rawgeti(L, LUA_REGISTRYINDEX, ud->client.cb_sent_ref);
  235. lua_rawgeti(L, LUA_REGISTRYINDEX, ud->self_ref);
  236. lua_call(L, 1, 0);
  237. return ERR_OK;
  238. }
  239. static err_t net_accept_cb(void *arg, struct tcp_pcb *newpcb, err_t err) {
  240. lnet_userdata *ud = (lnet_userdata*)arg;
  241. if (!ud || ud->type != TYPE_TCP_SERVER || !ud->pcb) return ERR_ABRT;
  242. if (ud->self_ref == LUA_NOREF || ud->server.cb_accept_ref == LUA_NOREF) return ERR_ABRT;
  243. lua_State *L = lua_getstate();
  244. lua_rawgeti(L, LUA_REGISTRYINDEX, ud->server.cb_accept_ref);
  245. lnet_userdata *nud = net_create(L, TYPE_TCP_CLIENT);
  246. lua_pushvalue(L, 2);
  247. nud->self_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  248. nud->tcp_pcb = newpcb;
  249. tcp_arg(nud->tcp_pcb, nud);
  250. tcp_err(nud->tcp_pcb, net_err_cb);
  251. tcp_recv(nud->tcp_pcb, net_tcp_recv_cb);
  252. tcp_sent(nud->tcp_pcb, net_sent_cb);
  253. nud->tcp_pcb->so_options |= SOF_KEEPALIVE;
  254. nud->tcp_pcb->keep_idle = ud->server.timeout * 1000;
  255. nud->tcp_pcb->keep_cnt = 1;
  256. tcp_accepted(ud->tcp_pcb);
  257. lua_call(L, 1, 0);
  258. return net_connected_cb(nud, nud->tcp_pcb, ERR_OK);
  259. }
  260. #pragma mark - Lua API - create
  261. #ifdef TLS_MODULE_PRESENT
  262. extern int tls_socket_create( lua_State *L );
  263. #endif
  264. // Lua: net.createUDPSocket()
  265. int net_createUDPSocket( lua_State *L ) {
  266. net_create(L, TYPE_UDP_SOCKET);
  267. return 1;
  268. }
  269. // Lua: net.createServer(type, timeout)
  270. int net_createServer( lua_State *L ) {
  271. int type, timeout;
  272. type = luaL_optlong(L, 1, TYPE_TCP);
  273. timeout = luaL_optlong(L, 2, 30);
  274. if (type == TYPE_UDP) {
  275. platform_print_deprecation_note("net.createServer with net.UDP type", "in next version");
  276. return net_createUDPSocket( L );
  277. }
  278. if (type != TYPE_TCP) return luaL_error(L, "invalid type");
  279. lnet_userdata *u = net_create(L, TYPE_TCP_SERVER);
  280. u->server.timeout = timeout;
  281. return 1;
  282. }
  283. // Lua: net.createConnection(type, secure)
  284. int net_createConnection( lua_State *L ) {
  285. int type, secure;
  286. type = luaL_optlong(L, 1, TYPE_TCP);
  287. secure = luaL_optlong(L, 2, 0);
  288. if (type == TYPE_UDP) {
  289. platform_print_deprecation_note("net.createConnection with net.UDP type", "in next version");
  290. return net_createUDPSocket( L );
  291. }
  292. if (type != TYPE_TCP) return luaL_error(L, "invalid type");
  293. if (secure) {
  294. platform_print_deprecation_note("net.createConnection with secure flag", "in next version");
  295. #ifdef TLS_MODULE_PRESENT
  296. return tls_socket_create( L );
  297. #else
  298. return luaL_error(L, "secure connections not enabled");
  299. #endif
  300. }
  301. net_create(L, TYPE_TCP_CLIENT);
  302. return 1;
  303. }
  304. #pragma mark - Get & check userdata
  305. lnet_userdata *net_get_udata_s( lua_State *L, int stack ) {
  306. if (!lua_isuserdata(L, stack)) return NULL;
  307. lnet_userdata *ud = (lnet_userdata *)lua_touserdata(L, stack);
  308. switch (ud->type) {
  309. case TYPE_TCP_CLIENT:
  310. case TYPE_TCP_SERVER:
  311. case TYPE_UDP_SOCKET:
  312. break;
  313. default: return NULL;
  314. }
  315. const char *mt = NET_TABLES[ud->type];
  316. ud = luaL_checkudata(L, stack, mt);
  317. return ud;
  318. }
  319. #define net_get_udata(L) net_get_udata_s(L, 1)
  320. #pragma mark - Lua API
  321. // Lua: server:listen(port, addr, function(c)), socket:listen(port, addr)
  322. int net_listen( lua_State *L ) {
  323. lnet_userdata *ud = net_get_udata(L);
  324. if (!ud || ud->type == TYPE_TCP_CLIENT)
  325. return luaL_error(L, "invalid user data");
  326. if (ud->pcb)
  327. return luaL_error(L, "already listening");
  328. int stack = 2;
  329. uint16_t port = 0;
  330. const char *domain = "0.0.0.0";
  331. if (lua_isnumber(L, stack))
  332. port = lua_tointeger(L, stack++);
  333. if (lua_isstring(L, stack)) {
  334. size_t dl = 0;
  335. domain = luaL_checklstring(L, stack++, &dl);
  336. }
  337. ip_addr_t addr;
  338. if (!ipaddr_aton(domain, &addr))
  339. return luaL_error(L, "invalid IP address");
  340. if (ud->type == TYPE_TCP_SERVER) {
  341. if (lua_isfunction(L, stack) || lua_islightfunction(L, stack)) {
  342. lua_pushvalue(L, stack++);
  343. luaL_unref(L, LUA_REGISTRYINDEX, ud->server.cb_accept_ref);
  344. ud->server.cb_accept_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  345. } else {
  346. return luaL_error(L, "need callback");
  347. }
  348. }
  349. err_t err = ERR_OK;
  350. switch (ud->type) {
  351. case TYPE_TCP_SERVER:
  352. ud->tcp_pcb = tcp_new();
  353. if (!ud->tcp_pcb)
  354. return luaL_error(L, "cannot allocate PCB");
  355. ud->tcp_pcb->so_options |= SOF_REUSEADDR;
  356. err = tcp_bind(ud->tcp_pcb, &addr, port);
  357. if (err == ERR_OK) {
  358. tcp_arg(ud->tcp_pcb, ud);
  359. struct tcp_pcb *pcb = tcp_listen(ud->tcp_pcb);
  360. if (!pcb) {
  361. err = ERR_MEM;
  362. } else {
  363. ud->tcp_pcb = pcb;
  364. tcp_accept(ud->tcp_pcb, net_accept_cb);
  365. }
  366. }
  367. break;
  368. case TYPE_UDP_SOCKET:
  369. ud->udp_pcb = udp_new();
  370. if (!ud->udp_pcb)
  371. return luaL_error(L, "cannot allocate PCB");
  372. udp_recv(ud->udp_pcb, net_udp_recv_cb, ud);
  373. err = udp_bind(ud->udp_pcb, &addr, port);
  374. break;
  375. }
  376. if (err != ERR_OK) {
  377. switch (ud->type) {
  378. case TYPE_TCP_SERVER:
  379. tcp_close(ud->tcp_pcb);
  380. ud->tcp_pcb = NULL;
  381. break;
  382. case TYPE_UDP_SOCKET:
  383. udp_remove(ud->udp_pcb);
  384. ud->udp_pcb = NULL;
  385. break;
  386. }
  387. return lwip_lua_checkerr(L, err);
  388. }
  389. if (ud->self_ref == LUA_NOREF) {
  390. lua_pushvalue(L, 1);
  391. ud->self_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  392. }
  393. return 0;
  394. }
  395. // Lua: client:connect(port, addr)
  396. int net_connect( lua_State *L ) {
  397. lnet_userdata *ud = net_get_udata(L);
  398. if (!ud || ud->type != TYPE_TCP_CLIENT)
  399. return luaL_error(L, "invalid user data");
  400. if (ud->pcb)
  401. return luaL_error(L, "already connected");
  402. uint16_t port = luaL_checkinteger(L, 2);
  403. if (port == 0)
  404. return luaL_error(L, "specify port");
  405. const char *domain = "127.0.0.1";
  406. if (lua_isstring(L, 3)) {
  407. size_t dl = 0;
  408. domain = luaL_checklstring(L, 3, &dl);
  409. }
  410. if (lua_gettop(L) > 3) {
  411. luaL_argcheck(L, lua_isfunction(L, 4) || lua_islightfunction(L, 4), 4, "not a function");
  412. lua_pushvalue(L, 4);
  413. luaL_unref(L, LUA_REGISTRYINDEX, ud->client.cb_connect_ref);
  414. ud->client.cb_connect_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  415. }
  416. ud->tcp_pcb = tcp_new();
  417. if (!ud->tcp_pcb)
  418. return luaL_error(L, "cannot allocate PCB");
  419. tcp_arg(ud->tcp_pcb, ud);
  420. tcp_err(ud->tcp_pcb, net_err_cb);
  421. tcp_recv(ud->tcp_pcb, net_tcp_recv_cb);
  422. tcp_sent(ud->tcp_pcb, net_sent_cb);
  423. ud->tcp_pcb->remote_port = port;
  424. ip_addr_t addr;
  425. ud->client.wait_dns ++;
  426. int unref = 0;
  427. if (ud->self_ref == LUA_NOREF) {
  428. unref = 1;
  429. lua_pushvalue(L, 1);
  430. ud->self_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  431. }
  432. err_t err = dns_gethostbyname(domain, &addr, net_dns_cb, ud);
  433. if (err == ERR_OK) {
  434. net_dns_cb(domain, &addr, ud);
  435. } else if (err != ERR_INPROGRESS) {
  436. ud->client.wait_dns --;
  437. if (unref) {
  438. luaL_unref(L, LUA_REGISTRYINDEX, ud->self_ref);
  439. ud->self_ref = LUA_NOREF;
  440. }
  441. tcp_abort(ud->tcp_pcb);
  442. ud->tcp_pcb = NULL;
  443. return lwip_lua_checkerr(L, err);
  444. }
  445. return 0;
  446. }
  447. // Lua: client/socket:on(name, callback)
  448. int net_on( lua_State *L ) {
  449. lnet_userdata *ud = net_get_udata(L);
  450. if (!ud || ud->type == TYPE_TCP_SERVER)
  451. return luaL_error(L, "invalid user data");
  452. int *refptr = NULL;
  453. const char *name = luaL_checkstring(L, 2);
  454. if (!name) return luaL_error(L, "need callback name");
  455. switch (ud->type) {
  456. case TYPE_TCP_CLIENT:
  457. if (strcmp("connection",name)==0)
  458. { refptr = &ud->client.cb_connect_ref; break; }
  459. if (strcmp("disconnection",name)==0)
  460. { refptr = &ud->client.cb_disconnect_ref; break; }
  461. if (strcmp("reconnection",name)==0)
  462. { refptr = &ud->client.cb_reconnect_ref; break; }
  463. case TYPE_UDP_SOCKET:
  464. if (strcmp("dns",name)==0)
  465. { refptr = &ud->client.cb_dns_ref; break; }
  466. if (strcmp("receive",name)==0)
  467. { refptr = &ud->client.cb_receive_ref; break; }
  468. if (strcmp("sent",name)==0)
  469. { refptr = &ud->client.cb_sent_ref; break; }
  470. break;
  471. default: return luaL_error(L, "invalid user data");
  472. }
  473. if (refptr == NULL)
  474. return luaL_error(L, "invalid callback name");
  475. if (lua_isfunction(L, 3) || lua_islightfunction(L, 3)) {
  476. lua_pushvalue(L, 3);
  477. luaL_unref(L, LUA_REGISTRYINDEX, *refptr);
  478. *refptr = luaL_ref(L, LUA_REGISTRYINDEX);
  479. } else if (lua_isnil(L, 3)) {
  480. luaL_unref(L, LUA_REGISTRYINDEX, *refptr);
  481. *refptr = LUA_NOREF;
  482. } else {
  483. return luaL_error(L, "invalid callback function");
  484. }
  485. return 0;
  486. }
  487. // Lua: client:send(data, function(c)), socket:send(port, ip, data, function(s))
  488. int net_send( lua_State *L ) {
  489. lnet_userdata *ud = net_get_udata(L);
  490. if (!ud || ud->type == TYPE_TCP_SERVER)
  491. return luaL_error(L, "invalid user data");
  492. ip_addr_t addr;
  493. uint16_t port;
  494. const char *data;
  495. size_t datalen = 0;
  496. int stack = 2;
  497. if (ud->type == TYPE_UDP_SOCKET) {
  498. size_t dl = 0;
  499. port = luaL_checkinteger(L, stack++);
  500. if (port == 0) return luaL_error(L, "need port");
  501. const char *domain = luaL_checklstring(L, stack++, &dl);
  502. if (!domain) return luaL_error(L, "need IP address");
  503. if (!ipaddr_aton(domain, &addr)) return luaL_error(L, "invalid IP address");
  504. }
  505. data = luaL_checklstring(L, stack++, &datalen);
  506. if (!data || datalen == 0) return luaL_error(L, "no data to send");
  507. if (lua_isfunction(L, stack) || lua_islightfunction(L, stack)) {
  508. lua_pushvalue(L, stack++);
  509. luaL_unref(L, LUA_REGISTRYINDEX, ud->client.cb_sent_ref);
  510. ud->client.cb_sent_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  511. }
  512. if (ud->type == TYPE_UDP_SOCKET && !ud->pcb) {
  513. ud->udp_pcb = udp_new();
  514. if (!ud->udp_pcb)
  515. return luaL_error(L, "cannot allocate PCB");
  516. udp_recv(ud->udp_pcb, net_udp_recv_cb, ud);
  517. ip_addr_t laddr = {0};
  518. err_t err = udp_bind(ud->udp_pcb, &laddr, 0);
  519. if (err != ERR_OK) {
  520. udp_remove(ud->udp_pcb);
  521. ud->udp_pcb = NULL;
  522. return lwip_lua_checkerr(L, err);
  523. }
  524. if (ud->self_ref == LUA_NOREF) {
  525. lua_pushvalue(L, 1);
  526. ud->self_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  527. }
  528. }
  529. if (!ud->pcb || ud->self_ref == LUA_NOREF)
  530. return luaL_error(L, "not connected");
  531. err_t err;
  532. if (ud->type == TYPE_UDP_SOCKET) {
  533. struct pbuf *pb = pbuf_alloc(PBUF_TRANSPORT, datalen, PBUF_RAM);
  534. if (!pb)
  535. return luaL_error(L, "cannot allocate message buffer");
  536. pbuf_take(pb, data, datalen);
  537. err = udp_sendto(ud->udp_pcb, pb, &addr, port);
  538. pbuf_free(pb);
  539. if (ud->client.cb_sent_ref != LUA_NOREF) {
  540. lua_rawgeti(L, LUA_REGISTRYINDEX, ud->client.cb_sent_ref);
  541. lua_rawgeti(L, LUA_REGISTRYINDEX, ud->self_ref);
  542. lua_call(L, 1, 0);
  543. }
  544. } else if (ud->type == TYPE_TCP_CLIENT) {
  545. err = tcp_write(ud->tcp_pcb, data, datalen, TCP_WRITE_FLAG_COPY);
  546. }
  547. return lwip_lua_checkerr(L, err);
  548. }
  549. // Lua: client:hold()
  550. int net_hold( lua_State *L ) {
  551. lnet_userdata *ud = net_get_udata(L);
  552. if (!ud || ud->type != TYPE_TCP_CLIENT)
  553. return luaL_error(L, "invalid user data");
  554. if (!ud->client.hold && ud->tcp_pcb) {
  555. ud->client.hold = 1;
  556. }
  557. return 0;
  558. }
  559. // Lua: client:unhold()
  560. int net_unhold( lua_State *L ) {
  561. lnet_userdata *ud = net_get_udata(L);
  562. if (!ud || ud->type != TYPE_TCP_CLIENT)
  563. return luaL_error(L, "invalid user data");
  564. if (ud->client.hold && ud->tcp_pcb) {
  565. ud->client.hold = 0;
  566. ud->tcp_pcb->flags |= TF_ACK_NOW;
  567. tcp_recved(ud->tcp_pcb, TCP_WND);
  568. }
  569. return 0;
  570. }
  571. // Lua: client/socket:dns(domain, callback(socket, addr))
  572. int net_dns( lua_State *L ) {
  573. lnet_userdata *ud = net_get_udata(L);
  574. if (!ud || ud->type == TYPE_TCP_SERVER)
  575. return luaL_error(L, "invalid user data");
  576. size_t dl = 0;
  577. const char *domain = luaL_checklstring(L, 2, &dl);
  578. if (!domain)
  579. return luaL_error(L, "no domain specified");
  580. if (lua_isfunction(L, 3) || lua_islightfunction(L, 3)) {
  581. luaL_unref(L, LUA_REGISTRYINDEX, ud->client.cb_dns_ref);
  582. lua_pushvalue(L, 3);
  583. ud->client.cb_dns_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  584. }
  585. if (ud->client.cb_dns_ref == LUA_NOREF)
  586. return luaL_error(L, "no callback specified");
  587. ud->client.wait_dns ++;
  588. int unref = 0;
  589. if (ud->self_ref == LUA_NOREF) {
  590. unref = 1;
  591. lua_pushvalue(L, 1);
  592. ud->self_ref = luaL_ref(L, LUA_REGISTRYINDEX);
  593. }
  594. ip_addr_t addr;
  595. err_t err = dns_gethostbyname(domain, &addr, net_dns_cb, ud);
  596. if (err == ERR_OK) {
  597. net_dns_cb(domain, &addr, ud);
  598. } else if (err != ERR_INPROGRESS) {
  599. ud->client.wait_dns --;
  600. if (unref) {
  601. luaL_unref(L, LUA_REGISTRYINDEX, ud->self_ref);
  602. ud->self_ref = LUA_NOREF;
  603. }
  604. return lwip_lua_checkerr(L, err);
  605. }
  606. return 0;
  607. }
  608. // Lua: client/socket:ttl([ttl])
  609. int net_ttl( lua_State *L ) {
  610. lnet_userdata *ud = net_get_udata(L);
  611. if (!ud || ud->type == TYPE_TCP_SERVER)
  612. return luaL_error(L, "invalid user data");
  613. if (!ud->pcb)
  614. return luaL_error(L, "socket is not open/bound yet");
  615. int ttl = luaL_optinteger(L, 2, -1);
  616. // Since `ttl` field is part of IP_PCB macro
  617. // (which are at beginning of both udp_pcb/tcp_pcb)
  618. // and PCBs declared as `union` there is safe to
  619. // access ttl field without checking for type.
  620. if (ttl == -1) {
  621. ttl = ud->udp_pcb->ttl;
  622. } else {
  623. ud->udp_pcb->ttl = ttl;
  624. }
  625. lua_pushinteger(L, ttl);
  626. return 1;
  627. }
  628. // Lua: client:getpeer()
  629. int net_getpeer( lua_State *L ) {
  630. lnet_userdata *ud = net_get_udata(L);
  631. if (!ud || ud->type != TYPE_TCP_CLIENT)
  632. return luaL_error(L, "invalid user data");
  633. if (!ud->pcb) {
  634. lua_pushnil(L);
  635. lua_pushnil(L);
  636. return 2;
  637. }
  638. uint16_t port = ud->tcp_pcb->remote_port;
  639. ip_addr_t addr = ud->tcp_pcb->remote_ip;
  640. if (port == 0) {
  641. lua_pushnil(L);
  642. lua_pushnil(L);
  643. return 2;
  644. }
  645. char addr_str[16];
  646. bzero(addr_str, 16);
  647. ets_sprintf(addr_str, IPSTR, IP2STR(&addr.addr));
  648. lua_pushinteger(L, port);
  649. lua_pushstring(L, addr_str);
  650. return 2;
  651. }
  652. // Lua: client/server/socket:getaddr()
  653. int net_getaddr( lua_State *L ) {
  654. lnet_userdata *ud = net_get_udata(L);
  655. if (!ud) return luaL_error(L, "invalid user data");
  656. if (!ud->pcb) {
  657. lua_pushnil(L);
  658. lua_pushnil(L);
  659. return 2;
  660. }
  661. uint16_t port;
  662. ip_addr_t addr;
  663. switch (ud->type) {
  664. case TYPE_TCP_CLIENT:
  665. case TYPE_TCP_SERVER:
  666. addr = ud->tcp_pcb->local_ip;
  667. port = ud->tcp_pcb->local_port;
  668. break;
  669. case TYPE_UDP_SOCKET:
  670. addr = ud->udp_pcb->local_ip;
  671. port = ud->udp_pcb->local_port;
  672. break;
  673. }
  674. if (port == 0) {
  675. lua_pushnil(L);
  676. lua_pushnil(L);
  677. return 2;
  678. }
  679. char addr_str[16];
  680. bzero(addr_str, 16);
  681. ets_sprintf(addr_str, IPSTR, IP2STR(&addr.addr));
  682. lua_pushinteger(L, port);
  683. lua_pushstring(L, addr_str);
  684. return 2;
  685. }
  686. #if 0
  687. static void dbg_print_ud(const char *title, lnet_userdata *ud) {
  688. int i;
  689. dbg_printf("%s: Userdata %p:", title, ud);
  690. for (i=0; i<(sizeof(*ud)/sizeof(uint32_t)); i++)
  691. dbg_printf( " 0x%08x", ((uint32_t *)ud)[i]);
  692. dbg_printf("\n");
  693. #endif
  694. // Lua: client/server/socket:close()
  695. int net_close( lua_State *L ) {
  696. lnet_userdata *ud = net_get_udata(L);
  697. if (!ud) return luaL_error(L, "invalid user data");
  698. if (ud->pcb) {
  699. switch (ud->type) {
  700. case TYPE_TCP_CLIENT:
  701. if (ERR_OK != tcp_close(ud->tcp_pcb)) {
  702. tcp_arg(ud->tcp_pcb, NULL);
  703. tcp_abort(ud->tcp_pcb);
  704. }
  705. ud->tcp_pcb = NULL;
  706. break;
  707. case TYPE_TCP_SERVER:
  708. tcp_close(ud->tcp_pcb);
  709. ud->tcp_pcb = NULL;
  710. break;
  711. case TYPE_UDP_SOCKET:
  712. udp_remove(ud->udp_pcb);
  713. ud->udp_pcb = NULL;
  714. break;
  715. }
  716. } else {
  717. return luaL_error(L, "not connected");
  718. }
  719. if (ud->type == TYPE_TCP_SERVER ||
  720. (ud->pcb == NULL && ud->client.wait_dns == 0)) {
  721. // lua_gc(L, LUA_GCSTOP, 0);
  722. luaL_unref(L, LUA_REGISTRYINDEX, ud->self_ref);
  723. ud->self_ref = LUA_NOREF;
  724. // lua_gc(L, LUA_GCRESTART, 0);
  725. }
  726. #if 0
  727. dbg_print_ud("close exit", ud);
  728. #endif
  729. return 0;
  730. }
  731. int net_delete( lua_State *L ) {
  732. lnet_userdata *ud = net_get_udata(L);
  733. if (!ud) return luaL_error(L, "no user data");
  734. if (ud->pcb) {
  735. switch (ud->type) {
  736. case TYPE_TCP_CLIENT:
  737. tcp_arg(ud->tcp_pcb, NULL);
  738. tcp_abort(ud->tcp_pcb);
  739. ud->tcp_pcb = NULL;
  740. break;
  741. case TYPE_TCP_SERVER:
  742. tcp_close(ud->tcp_pcb);
  743. ud->tcp_pcb = NULL;
  744. break;
  745. case TYPE_UDP_SOCKET:
  746. udp_remove(ud->udp_pcb);
  747. ud->udp_pcb = NULL;
  748. break;
  749. }
  750. }
  751. switch (ud->type) {
  752. case TYPE_TCP_CLIENT:
  753. luaL_unref(L, LUA_REGISTRYINDEX, ud->client.cb_connect_ref);
  754. ud->client.cb_connect_ref = LUA_NOREF;
  755. luaL_unref(L, LUA_REGISTRYINDEX, ud->client.cb_disconnect_ref);
  756. ud->client.cb_disconnect_ref = LUA_NOREF;
  757. luaL_unref(L, LUA_REGISTRYINDEX, ud->client.cb_reconnect_ref);
  758. ud->client.cb_reconnect_ref = LUA_NOREF;
  759. case TYPE_UDP_SOCKET:
  760. luaL_unref(L, LUA_REGISTRYINDEX, ud->client.cb_dns_ref);
  761. ud->client.cb_dns_ref = LUA_NOREF;
  762. luaL_unref(L, LUA_REGISTRYINDEX, ud->client.cb_receive_ref);
  763. ud->client.cb_receive_ref = LUA_NOREF;
  764. luaL_unref(L, LUA_REGISTRYINDEX, ud->client.cb_sent_ref);
  765. ud->client.cb_sent_ref = LUA_NOREF;
  766. break;
  767. case TYPE_TCP_SERVER:
  768. luaL_unref(L, LUA_REGISTRYINDEX, ud->server.cb_accept_ref);
  769. ud->server.cb_accept_ref = LUA_NOREF;
  770. break;
  771. }
  772. // lua_gc(L, LUA_GCSTOP, 0);
  773. luaL_unref(L, LUA_REGISTRYINDEX, ud->self_ref);
  774. ud->self_ref = LUA_NOREF;
  775. // lua_gc(L, LUA_GCRESTART, 0);
  776. #if 0
  777. dbg_print_ud("delete end", ud);
  778. #endif
  779. return 0;
  780. }
  781. #pragma mark - Multicast
  782. static int net_multicastJoinLeave( lua_State *L, int join) {
  783. size_t il;
  784. ip_addr_t multicast_addr;
  785. ip_addr_t if_addr;
  786. const char *multicast_ip;
  787. const char *if_ip;
  788. NODE_DBG("net_multicastJoin is called.\n");
  789. if(! lua_isstring(L,1) ) return luaL_error( L, "wrong arg type" );
  790. if_ip = luaL_checklstring( L, 1, &il );
  791. if (if_ip != NULL)
  792. if ( if_ip[0] == '\0' || stricmp(if_ip,"any") == 0)
  793. {
  794. if_ip = "0.0.0.0";
  795. il = 7;
  796. }
  797. if (if_ip == NULL || il > 15 || il < 7) return luaL_error( L, "invalid if ip" );
  798. if_addr.addr = ipaddr_addr(if_ip);
  799. if(! lua_isstring(L,2) ) return luaL_error( L, "wrong arg type" );
  800. multicast_ip = luaL_checklstring( L, 2, &il );
  801. if (multicast_ip == NULL || il > 15 || il < 7) return luaL_error( L, "invalid multicast ip" );
  802. multicast_addr.addr = ipaddr_addr(multicast_ip);
  803. if (join)
  804. {
  805. igmp_joingroup(&if_addr, &multicast_addr);
  806. }
  807. else
  808. {
  809. igmp_leavegroup(&if_addr, &multicast_addr);
  810. }
  811. return 0;
  812. }
  813. // Lua: net.multicastJoin(ifip, multicastip)
  814. // if ifip "" or "any" all interfaces are affected
  815. static int net_multicastJoin( lua_State* L ) {
  816. return net_multicastJoinLeave(L,1);
  817. }
  818. // Lua: net.multicastLeave(ifip, multicastip)
  819. // if ifip "" or "any" all interfaces are affected
  820. static int net_multicastLeave( lua_State* L ) {
  821. return net_multicastJoinLeave(L,0);
  822. }
  823. #pragma mark - DNS
  824. static void net_dns_static_cb(const char *name, ip_addr_t *ipaddr, void *callback_arg) {
  825. ip_addr_t addr;
  826. if (ipaddr != NULL)
  827. addr = *ipaddr;
  828. else addr.addr = 0xFFFFFFFF;
  829. int cb_ref = ((int*)callback_arg)[0];
  830. free(callback_arg);
  831. lua_State *L = lua_getstate();
  832. lua_rawgeti(L, LUA_REGISTRYINDEX, cb_ref);
  833. lua_pushnil(L);
  834. if (addr.addr != 0xFFFFFFFF) {
  835. char iptmp[20];
  836. size_t ipl = sprintf(iptmp, IPSTR, IP2STR(&addr.addr));
  837. lua_pushlstring(L, iptmp, ipl);
  838. } else {
  839. lua_pushnil(L);
  840. }
  841. lua_call(L, 2, 0);
  842. luaL_unref(L, LUA_REGISTRYINDEX, cb_ref);
  843. }
  844. // Lua: net.dns.resolve( domain, function(sk, ip) )
  845. static int net_dns_static( lua_State* L ) {
  846. size_t dl;
  847. const char* domain = luaL_checklstring(L, 1, &dl);
  848. if (!domain && dl > 128) {
  849. return luaL_error(L, "wrong domain");
  850. }
  851. luaL_checkanyfunction(L, 2);
  852. lua_pushvalue(L, 2); // copy argument (func) to the top of stack
  853. int cbref = luaL_ref(L, LUA_REGISTRYINDEX);
  854. if (cbref == LUA_NOREF) {
  855. return luaL_error(L, "wrong callback");
  856. }
  857. int *cbref_ptr = calloc(1, sizeof(int));
  858. cbref_ptr[0] = cbref;
  859. ip_addr_t addr;
  860. err_t err = dns_gethostbyname(domain, &addr, net_dns_static_cb, cbref_ptr);
  861. if (err == ERR_OK) {
  862. net_dns_static_cb(domain, &addr, cbref_ptr);
  863. return 0;
  864. } else if (err == ERR_INPROGRESS) {
  865. return 0;
  866. } else {
  867. int e = lwip_lua_checkerr(L, err);
  868. free(cbref_ptr);
  869. return e;
  870. }
  871. return 0;
  872. }
  873. // Lua: s = net.dns.setdnsserver(ip_addr, [index])
  874. static int net_setdnsserver( lua_State* L ) {
  875. size_t l;
  876. u32_t ip32;
  877. const char *server = luaL_checklstring( L, 1, &l );
  878. if (l>16 || server == NULL || (ip32 = ipaddr_addr(server)) == IPADDR_NONE || ip32 == IPADDR_ANY)
  879. return luaL_error( L, "invalid dns server ip" );
  880. int numdns = luaL_optint(L, 2, 0);
  881. if (numdns >= DNS_MAX_SERVERS)
  882. return luaL_error( L, "server index out of range [0-%d]", DNS_MAX_SERVERS - 1);
  883. ip_addr_t ipaddr;
  884. ip4_addr_set_u32(&ipaddr, ip32);
  885. dns_setserver(numdns,&ipaddr);
  886. return 0;
  887. }
  888. // Lua: s = net.dns.getdnsserver([index])
  889. static int net_getdnsserver( lua_State* L ) {
  890. int numdns = luaL_optint(L, 1, 0);
  891. if (numdns >= DNS_MAX_SERVERS)
  892. return luaL_error( L, "server index out of range [0-%d]", DNS_MAX_SERVERS - 1);
  893. // ip_addr_t ipaddr;
  894. // dns_getserver(numdns,&ipaddr);
  895. // Bug fix by @md5crypt https://github.com/nodemcu/nodemcu-firmware/pull/500
  896. ip_addr_t ipaddr = dns_getserver(numdns);
  897. if ( ip_addr_isany(&ipaddr) ) {
  898. lua_pushnil( L );
  899. } else {
  900. char temp[20] = {0};
  901. sprintf(temp, IPSTR, IP2STR( &ipaddr.addr ) );
  902. lua_pushstring( L, temp );
  903. }
  904. return 1;
  905. }
  906. #pragma mark - Tables
  907. #ifdef TLS_MODULE_PRESENT
  908. LROT_EXTERN(tls_cert);
  909. #endif
  910. // Module function map
  911. LROT_BEGIN(net_tcpserver)
  912. LROT_FUNCENTRY( listen, net_listen )
  913. LROT_FUNCENTRY( getaddr, net_getaddr )
  914. LROT_FUNCENTRY( close, net_close )
  915. LROT_FUNCENTRY( __gc, net_delete )
  916. LROT_TABENTRY( __index, net_tcpserver )
  917. LROT_END( net_tcpserver, net_tcpserver, 0 )
  918. LROT_BEGIN(net_tcpsocket)
  919. LROT_FUNCENTRY( connect, net_connect )
  920. LROT_FUNCENTRY( close, net_close )
  921. LROT_FUNCENTRY( on, net_on )
  922. LROT_FUNCENTRY( send, net_send )
  923. LROT_FUNCENTRY( hold, net_hold )
  924. LROT_FUNCENTRY( unhold, net_unhold )
  925. LROT_FUNCENTRY( dns, net_dns )
  926. LROT_FUNCENTRY( ttl, net_ttl )
  927. LROT_FUNCENTRY( getpeer, net_getpeer )
  928. LROT_FUNCENTRY( getaddr, net_getaddr )
  929. LROT_FUNCENTRY( __gc, net_delete )
  930. LROT_TABENTRY( __index, net_tcpsocket )
  931. LROT_END( net_tcpsocket, net_tcpsocket, 0 )
  932. LROT_BEGIN(net_udpsocket)
  933. LROT_FUNCENTRY( listen, net_listen )
  934. LROT_FUNCENTRY( close, net_close )
  935. LROT_FUNCENTRY( on, net_on )
  936. LROT_FUNCENTRY( send, net_send )
  937. LROT_FUNCENTRY( dns, net_dns )
  938. LROT_FUNCENTRY( ttl, net_ttl )
  939. LROT_FUNCENTRY( getaddr, net_getaddr )
  940. LROT_FUNCENTRY( __gc, net_delete )
  941. LROT_TABENTRY( __index, net_udpsocket )
  942. LROT_END( net_udpsocket, net_udpsocket, 0 )
  943. LROT_BEGIN(net_dns)
  944. LROT_FUNCENTRY( setdnsserver, net_setdnsserver )
  945. LROT_FUNCENTRY( getdnsserver, net_getdnsserver )
  946. LROT_FUNCENTRY( resolve, net_dns_static )
  947. LROT_END( net_dns, net_dns, 0 )
  948. LROT_BEGIN(net)
  949. LROT_FUNCENTRY( createServer, net_createServer )
  950. LROT_FUNCENTRY( createConnection, net_createConnection )
  951. LROT_FUNCENTRY( createUDPSocket, net_createUDPSocket )
  952. LROT_FUNCENTRY( multicastJoin, net_multicastJoin )
  953. LROT_FUNCENTRY( multicastLeave, net_multicastLeave )
  954. LROT_TABENTRY( dns, net_dns )
  955. #ifdef TLS_MODULE_PRESENT
  956. LROT_TABENTRY( cert, tls_cert )
  957. #endif
  958. LROT_NUMENTRY( TCP, TYPE_TCP )
  959. LROT_NUMENTRY( UDP, TYPE_UDP )
  960. LROT_TABENTRY( __metatable, net )
  961. LROT_END( net, net, 0 )
  962. int luaopen_net( lua_State *L ) {
  963. igmp_init();
  964. luaL_rometatable(L, NET_TABLE_TCP_SERVER, LROT_TABLEREF(net_tcpserver));
  965. luaL_rometatable(L, NET_TABLE_TCP_CLIENT, LROT_TABLEREF(net_tcpsocket));
  966. luaL_rometatable(L, NET_TABLE_UDP_SOCKET, LROT_TABLEREF(net_udpsocket));
  967. return 0;
  968. }
  969. NODEMCU_MODULE(NET, "net", net, luaopen_net);