Refactoring for PicoRuby and Microruby

- DNS_resolve: Set outbuf as an argument instead of return mrb_value
- picorb_warn instead of mrb_warn

Author: hasumikin

mrbgems/picoruby-net/include/net.h

@@ -21,7 +21,13 @@ void lwip_end(void);
 void Net_sleep_ms(int);
 err_t Net_get_ip(const char *name, ip_addr_t *ip);
 
-mrb_value DNS_resolve(mrb_state *mrb, const char *name, bool is_tcp);
+#if defined(PICORB_VM_MRUBYC)
+#define mrb_state mrbc_vm
+#endif
+
+#define OUTBUF_SIZE 16
+
+void DNS_resolve(const char *name, bool is_tcp, char *outbuf, size_t outlen);
 mrb_value TCPClient_send(const char *host, int port, mrb_state *mrb, mrb_value send_data, bool is_tls);
 mrb_value UDPClient_send(const char *host, int port, mrb_state *mrb, mrb_value send_data, bool is_dtls);
 

mrbgems/picoruby-net/src/mruby/dns.c

@@ -4,21 +4,17 @@
 
 #include "mruby.h"
 
-mrb_value
-DNS_resolve(mrb_state *mrb, const char *name, bool is_tcp)
+void
+DNS_resolve(const char *name, bool is_tcp, char *outbuf, size_t outlen)
 {
   (void)is_tcp;
   ip_addr_t ip;
-  mrb_value ret;
   ip4_addr_set_zero(&ip);
   Net_get_ip(name, &ip);
-  if(!ip4_addr_isloopback(&ip)) {
-    char buf[16];
-    ipaddr_ntoa_r(&ip, buf, 16);
-    ret = mrb_str_new(mrb, buf, strlen(buf));
+  if (!ip4_addr_isloopback(&ip)) {
+    ipaddr_ntoa_r(&ip, outbuf, outlen);
   } else {
-    ret = mrb_nil_value();
+    outbuf[0] = '\0';
   }
-  return ret;
 }
 

mrbgems/picoruby-net/src/mruby/net.c

@@ -9,7 +9,13 @@ mrb_net_dns_s_resolve(mrb_state *mrb, mrb_value self)
   const char *host;
   mrb_bool is_tls;
   mrb_get_args(mrb, "zb", &host, &is_tls);
-  return DNS_resolve(mrb, host, is_tls);
+  char outbuf[OUTBUF_SIZE];
+  DNS_resolve(host, is_tls, outbuf, sizeof(outbuf));
+  if (outbuf[0] == '\0') {
+    return mrb_nil_value();
+  } else {
+    return mrb_str_new_cstr(mrb, outbuf);
+  }
 }
 
 static mrb_value

mrbgems/picoruby-net/src/mruby/tcp.c

@@ -44,6 +44,7 @@ TCPClient_close(tcp_connection_state *cs)
 {
   err_t err = ERR_OK;
   if (!cs || !cs->pcb) return ERR_ARG;
+  mrb_state *mrb = cs->mrb;
   lwip_begin();
   altcp_arg(cs->pcb, NULL);
   altcp_recv(cs->pcb, NULL);
@@ -52,27 +53,28 @@ TCPClient_close(tcp_connection_state *cs)
   altcp_poll(cs->pcb, NULL, 0);
   err = altcp_close(cs->pcb);
   if (err != ERR_OK) {
-    mrb_warn(cs->mrb, "altcp_close failed: %d\n", err);
+    picorb_warn("altcp_close failed: %d\n", err);
     altcp_abort(cs->pcb);
     err = ERR_ABRT;
   }
   lwip_end();
   TCPClient_free_tls_config(cs);
-  mrb_free(cs->mrb, cs);
+  mrb_free(mrb, cs);
   return err;
 }
 
 static err_t
 TCPClient_recv_cb(void *arg, struct altcp_pcb *pcb, struct pbuf *pbuf, err_t err)
 {
   tcp_connection_state *cs = (tcp_connection_state *)arg;
+  mrb_state *mrb = cs->mrb;
   if (err != ERR_OK) {
-    mrb_warn(cs->mrb, "TCPClient_recv_cb: err=%d\n", err);
+    picorb_warn("TCPClient_recv_cb: err=%d\n", err);
     cs->state = NET_TCP_STATE_ERROR;
     return TCPClient_close(cs);
   }
   if (pbuf != NULL) {
-    char *tmpbuf = mrb_malloc(cs->mrb, pbuf->tot_len + 1);
+    char *tmpbuf = mrb_malloc(mrb, pbuf->tot_len + 1);
     struct pbuf *current_pbuf = pbuf;
     int offset = 0;
     while (current_pbuf != NULL) {
@@ -81,8 +83,8 @@ TCPClient_recv_cb(void *arg, struct altcp_pcb *pcb, struct pbuf *pbuf, err_t err
       current_pbuf = current_pbuf->next;
     }
     tmpbuf[pbuf->tot_len] = '\0';
-    mrb_str_cat(cs->mrb, cs->recv_data, tmpbuf, pbuf->tot_len);
-    mrb_free(cs->mrb, tmpbuf);
+    mrb_str_cat(mrb, cs->recv_data, tmpbuf, pbuf->tot_len);
+    mrb_free(mrb, tmpbuf);
     altcp_recved(pcb, pbuf->tot_len);
     cs->state = NET_TCP_STATE_PACKET_RECVED;
     pbuf_free(pbuf);
@@ -102,11 +104,12 @@ TCPClient_sent_cb(void *arg, struct altcp_pcb *pcb, u16_t len)
 static err_t
 TCPClient_connected_cb(void *arg, struct altcp_pcb *pcb, err_t err)
 {
+  tcp_connection_state *cs = (tcp_connection_state *)arg;
+  mrb_state *mrb = cs->mrb;
   if (err != ERR_OK) {
-    printf("TCPClient_connected_cb: err=%d\n", err);
+    picorb_warn("TCPClient_connected_cb: err=%d\n", err);
     return TCPClient_close((tcp_connection_state *)arg);
   }
-  tcp_connection_state *cs = (tcp_connection_state *)arg;
   cs->state = NET_TCP_STATE_CONNECTED;
   return ERR_OK;
 }
@@ -115,7 +118,8 @@ static err_t
 TCPClient_poll_cb(void *arg, struct altcp_pcb *pcb)
 {
   tcp_connection_state *cs = (tcp_connection_state *)arg;
-  mrb_warn(cs->mrb, "TCPClient_poll_cb (timeout)\n");
+  mrb_state *mrb = cs->mrb;
+  picorb_warn("TCPClient_poll_cb (timeout)\n");
   cs->state = NET_TCP_STATE_TIMEOUT;
   return ERR_OK;
 }
@@ -124,7 +128,8 @@ static void
 TCPClient_err_cb(void *arg, err_t err)
 {
   tcp_connection_state *cs = (tcp_connection_state *)arg;
-  mrb_warn(cs->mrb, "Error with: %d\n", err);
+  mrb_state *mrb = cs->mrb;
+  picorb_warn("Error with: %d\n", err);
   cs->state = NET_TCP_STATE_ERROR;
 }
 
@@ -155,7 +160,7 @@ TCPClient_new_tls_connection(const char *host, mrb_value send_data, mrb_value re
   struct altcp_tls_config *tls_config = altcp_tls_create_config_client(NULL, 0);
   cs->pcb = altcp_tls_new(tls_config, IPADDR_TYPE_V4);
   if (!cs->pcb) {
-    mrb_warn(cs->mrb, "altcp_tls_new failed\n");
+    picorb_warn("altcp_tls_new failed\n");
     mrb_free(mrb, cs);
     return NULL;
   }
@@ -186,7 +191,7 @@ TCPClient_connect_impl(ip_addr_t *ip, const char *host, int port, mrb_value send
     lwip_begin();
     err = altcp_connect(cs->pcb, ip, port, TCPClient_connected_cb);
     if (err != ERR_OK) {
-      mrb_warn(cs->mrb, "altcp_connect failed: %d\n", err);
+      picorb_warn("altcp_connect failed: %d\n", err);
       cs->state = NET_TCP_STATE_ERROR;
       lwip_end();
       return cs;
@@ -217,7 +222,8 @@ TCPClient_poll_impl(tcp_connection_state **pcs)
       lwip_begin();
       err = altcp_write(cs->pcb, RSTRING_PTR(cs->send_data), RSTRING_LEN(cs->send_data), 0);
       if (err != ERR_OK) {
-        mrb_warn(cs->mrb, "altcp_write failed: %d\n", err);
+        mrb_state *mrb = cs->mrb;
+        picorb_warn("altcp_write failed: %d\n", err);
         cs->state = NET_TCP_STATE_ERROR;
         return 1;
       }

mrbgems/picoruby-net/src/mruby/udp.c

@@ -32,9 +32,10 @@ static void
 UDPClient_recv_cb(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port)
 {
   udp_connection_state *cs = (udp_connection_state *)arg;
+  mrb_state *mrb = cs->mrb;
 
   if (p != NULL) {
-    char *tmpbuf = mrb_malloc(cs->mrb, p->tot_len + 1);
+    char *tmpbuf = mrb_malloc(mrb, p->tot_len + 1);
     pbuf_copy_partial(p, tmpbuf, p->tot_len, 0);
     tmpbuf[p->tot_len] = '\0';
     mrb_str_cat(cs->mrb, cs->recv_data, tmpbuf, p->tot_len);
@@ -43,7 +44,7 @@ UDPClient_recv_cb(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_
     pbuf_free(p);
   } else {
     cs->state = NET_UDP_STATE_ERROR;
-    mrb_warn(cs->mrb, "State changed to NET_UDP_STATE_ERROR\n");
+    picorb_warn("State changed to NET_UDP_STATE_ERROR\n");
   }
 }
 
@@ -54,7 +55,7 @@ UDPClient_new_connection(mrb_value send_data, mrb_value recv_data, mrb_state *mr
   cs->state = NET_UDP_STATE_NONE;
   cs->pcb = udp_new();
   if (cs->pcb == NULL) {
-    mrb_warn(cs->mrb, "Failed to create new UDP PCB\n");
+    picorb_warn("Failed to create new UDP PCB\n");
     return NULL;
   }
   udp_recv(cs->pcb, UDPClient_recv_cb, cs);
@@ -70,7 +71,7 @@ UDPClient_send_impl(ip_addr_t *ip, int port, mrb_value send_data, mrb_value recv
   (void)is_dtls;
   udp_connection_state *cs = UDPClient_new_connection(send_data, recv_data, mrb);
   if (cs == NULL) {
-    mrb_warn(cs->mrb, "Failed to create new connection\n");
+    picorb_warn("Failed to create new connection\n");
     return NULL;
   }
 
@@ -89,11 +90,11 @@ UDPClient_send_impl(ip_addr_t *ip, int port, mrb_value send_data, mrb_value recv
       cs->state = NET_UDP_STATE_WAITING;
     } else {
       cs->state = NET_UDP_STATE_ERROR;
-      mrb_warn(cs->mrb, "Failed to send UDP packet, error: %d\n", err);
+      picorb_warn("Failed to send UDP packet, error: %d\n", err);
     }
   } else {
     cs->state = NET_UDP_STATE_ERROR;
-    mrb_warn(cs->mrb, "Failed to allocate pbuf for send data\n");
+    picorb_warn("Failed to allocate pbuf for send data\n");
   }
 
   return cs;
@@ -122,7 +123,8 @@ UDPClient_poll_impl(udp_connection_state **pcs)
       *pcs = NULL;
       return 0;
     case NET_UDP_STATE_ERROR:
-      mrb_warn(cs->mrb, "Error occurred, cleaning up\n");
+      mrb_state *mrb = cs->mrb;
+      picorb_warn("Error occurred, cleaning up\n");
       lwip_begin();
       udp_remove(cs->pcb);
       lwip_end();
@@ -145,9 +147,10 @@ UDPClient_send(const char *host, int port, mrb_state *mrb, mrb_value send_data,
   if(!ip4_addr_isloopback(&ip)) {
     mrb_value recv_data = mrb_str_new_capa(mrb, 0);
     udp_connection_state *cs = UDPClient_send_impl(&ip, port, send_data, recv_data, mrb, is_dtls);
+    mrb_state *mrb = cs->mrb;
 
     if (cs == NULL) {
-      mrb_warn(cs->mrb, "Failed to create UDP connection\n");
+      picorb_warn("Failed to create UDP connection\n");
       ret = mrb_nil_value();
     } else {
       int poll_count = 0;
@@ -157,21 +160,21 @@ UDPClient_send(const char *host, int port, mrb_state *mrb, mrb_value send_data,
         Net_sleep_ms(200);
         // Add a timeout mechanism to prevent infinite loop
         if (poll_count > 50) { // 10 seconds timeout (50 * 200ms)
-          mrb_warn(cs->mrb, "Polling timeout reached\n");
+          picorb_warn("Polling timeout reached\n");
           break;
         }
       }
       if (cs != NULL) {
-        mrb_warn(cs->mrb, "Connection state not NULL after polling, cleaning up\n");
+        picorb_warn("Connection state not NULL after polling, cleaning up\n");
         lwip_begin();
         udp_remove(cs->pcb);
         lwip_end();
-        mrb_free(cs->mrb, cs);
+        mrb_free(mrb, cs);
       }
       ret = recv_data;
     }
   } else {
-    mrb_warn(mrb, "IP is loopback, not sending\n");
+    picorb_warn("IP is loopback, not sending\n");
     ret = mrb_nil_value();
   }
   return ret;