Merge pull request #680 from nkolban/master

Function for #589 and comment removals

Author: gfwilliams

libs/network/esp8266/jswrap_esp8266.c

@@ -259,6 +259,7 @@ void jswrap_ESP8266_wifi_stopAP(JsVar *jsCallback) {
 * When the outcome is known, the callback function is invoked.  The options object contains
 * properties that control the connection.  Included in this object are:
 * * autoConnect (Boolean) - When true, these settings will be used to autoConnect on next boot.
+* * dnsServers (array of String) - An array of up to two DNS servers in dotted decimal format string.
 */
 void jswrap_ESP8266_wifi_connect(
     JsVar *jsSsid,
@@ -401,7 +402,48 @@ void jswrap_ESP8266_wifi_connect(
      }
    }
    jsvUnLock(jsAutoConnect);
- }
+   // End of autoConnect processing
+
+   // Do we have a child property called dnsServers?
+   JsVar *jsDNSServers = jsvObjectGetChild(jsOptions, "dnsServers", 0);
+   if (jsvIsArray(jsDNSServers) != false) {
+     os_printf(" - We have DNS servers!!\n");
+     JsVarInt numDNSServers = jsvGetArrayLength(jsDNSServers);
+     ip_addr_t dnsAddresses[2];
+     int count;
+     if (numDNSServers == 0) {
+       os_printf("No servers!!");
+       count = 0;
+     }
+     if (numDNSServers > 0) {
+       // One server
+       count = 1;
+       JsVar *jsCurrentDNSServer = jsvGetArrayItem(jsDNSServers, 0);
+       char buffer[50];
+       size_t size = jsvGetString(jsCurrentDNSServer, buffer, sizeof(buffer)-1);
+       buffer[size] = '\0';
+       jsvUnLock(jsCurrentDNSServer);
+       dnsAddresses[0].addr = networkParseIPAddress(buffer);
+     }
+     if (numDNSServers > 1) {
+       // Two servers
+       count = 2;
+       JsVar *jsCurrentDNSServer = jsvGetArrayItem(jsDNSServers, 1);
+       char buffer[50];
+       size_t size = jsvGetString(jsCurrentDNSServer, buffer, sizeof(buffer)-1);
+       buffer[size] = '\0';
+       jsvUnLock(jsCurrentDNSServer);
+       dnsAddresses[1].addr = networkParseIPAddress(buffer);
+     }
+     if (numDNSServers > 2) {
+       os_printf("Ignoring DNS servers after first 2.");
+     }
+     if (count > 0) {
+       espconn_dns_setserver((char)count, dnsAddresses);
+     }
+   }
+   jsvUnLock(jsDNSServers);
+ } // End of dnsServers processing
 
  // Perform the network level connection.
  wifi_station_connect();
@@ -1204,13 +1246,12 @@ void jswrap_ESP8266_updateCPUFreq(
  */
 /*JSON{
   "type"     : "staticmethod",
-  "class"    : "ESP8266WiFi",
+  "class"    : "ESP8266",
   "name"     : "getState",
-  "generate" : "jswrap_ESP8266WiFi_getState",
-  "return"   : ["JsVar","The state of the ESP8266"],
-  "return_object" : "ESP8266State"
+  "generate" : "jswrap_ESP8266_getState",
+  "return"   : ["JsVar", "The state of the ESP8266"]
 }*/
-JsVar *jswrap_ESP8266WiFi_getState() {
+JsVar *jswrap_ESP8266_getState() {
   // Create a new variable and populate it with the properties of the ESP8266 that we
   // wish to return.
   JsVar *esp8266State = jspNewObject(NULL, "ESP8266State");
@@ -1348,11 +1389,14 @@ static void dnsFoundCallback(
     void *arg             //!< Parameter passed in from espconn_gethostbyname.
   ) {
   os_printf(">> dnsFoundCallback - %s %x\n", hostname, ipAddr->addr);
-  assert(g_jsHostByNameCallback != NULL);
-  JsVar *params[1];
-  params[0] = jsvNewFromInteger(ipAddr->addr);
-  jsiQueueEvents(NULL, g_jsHostByNameCallback, params, 1);
-  jsvUnLock(params[0]);
+  if (g_jsHostByNameCallback != NULL) {
+    JsVar *params[1];
+    params[0] = jsvNewFromInteger(ipAddr->addr);
+    jsiQueueEvents(NULL, g_jsHostByNameCallback, params, 1);
+    jsvUnLock(params[0]);
+    jsvUnLock(g_jsHostByNameCallback);
+    g_jsHostByNameCallback = NULL;
+  }
   os_printf("<< dnsFoundCallback\n");
 }
 
@@ -1676,13 +1720,25 @@ void jswrap_ESP8266_ping(
     ["socketId","JsVar","The socket to be dumped."]
   ]
 }*/
-
 void jswrap_ESP8266_dumpSocket(
     JsVar *socketId //!< The socket to be dumped.
   ) {
   esp8266_dumpSocket(jsvGetInteger(socketId)-1);
 }
 
+/*JSON{
+  "type"     : "staticmethod",
+  "class"    : "ESP8266",
+  "name"     : "dumpAllSocketData",
+  "generate" : "jswrap_ESP8266_dumpAllSocketData"
+}
+* Write all the socket data structures to the debug log.
+* This is purely a diagnostic function.
+*/
+void jswrap_ESP8266_dumpAllSocketData() {
+  esp8266_dumpAllSocketData();
+}
+
 /**
  * Null terminate a string.
  */

libs/network/esp8266/jswrap_esp8266.h

@@ -34,7 +34,6 @@ JsVar *jswrap_ESP8266WiFi_getDHCPHostname();
 // Deprecated
 JsVar *jswrap_ESP8266WiFi_getIPInfo();
 JsVar *jswrap_ESP8266WiFi_getRSSI();
-JsVar *jswrap_ESP8266WiFi_getState();
 JsVar *jswrap_ESP8266WiFi_getStationConfig();
 void   jswrap_ESP8266WiFi_init();
 void   jswrap_ESP8266WiFi_kill();
@@ -54,10 +53,12 @@ JsVar *jswrap_ESP8266_wifi_getIP();
 void   jswrap_ESP8266_wifi_scan(JsVar *jsCallback);
 void   jswrap_ESP8266_wifi_stopAP(JsVar *jsCallback);
 
+void   jswrap_ESP8266_dumpAllSocketData();
 void   jswrap_ESP8266_dumpSocket(JsVar *jsSocketId);
 JsVar *jswrap_ESP8266_getAddressAsString(JsVar *jsAddress);
 void   jswrap_ESP8266_getHostByName(JsVar *jsHostname, JsVar *jsCallback);
 JsVar *jswrap_ESP8266_getRstInfo();
+JsVar *jswrap_ESP8266_getState();
 void   jswrap_ESP8266_logDebug(JsVar *jsDebug);
 void   jswrap_ESP8266_ping(JsVar *jsIpAddr, JsVar *jsPingCallback);
 void   jswrap_ESP8266_restart();

libs/network/esp8266/network_esp8266.c

@@ -82,6 +82,7 @@ static void doClose(int socketId);
 static void releaseSocket(int socketId);
 static void resetSocketByData(struct socketData *pSocketData);
 static void resetSocketById(int sckt);
+static void esp8266_dumpSocketData(struct socketData *pSocketData);
 
 static void esp8266_callback_connectCB_inbound(void *arg);
 static void esp8266_callback_connectCB_outbound(void *arg);
@@ -219,6 +220,18 @@ static struct socketData socketArray[MAX_SOCKETS];
  */
 static bool g_socketsInitialized = false;
 
+/**
+ * Dump all the socket structures.
+ * This is used exclusively for debugging.  It walks through each of the
+ * socket structures and dumps their state to the debug log.
+ */
+void esp8266_dumpAllSocketData() {
+  int i;
+  for (i=0; i<MAX_SOCKETS; i++) {
+    esp8266_dumpSocketData(&socketArray[i]);
+  }
+}
+
 
 /**
  * Write the details of a socket to the debug log.
@@ -228,7 +241,18 @@ void esp8266_dumpSocket(
     int socketId //!< The ID of the socket data structure to be logged.
   ) {
   struct socketData *pSocketData = getSocketData(socketId);
-  LOG("Dump of socket=%d\n", socketId);
+  esp8266_dumpSocketData(pSocketData);
+}
+
+
+/**
+ * Write the details of a socketData to the debug log.
+ * The data associated with the socketData is dumped to the debug log.
+ */
+static void esp8266_dumpSocketData(
+    struct socketData *pSocketData //!< The socket data structure to be logged
+  ) {
+  LOG("Dump of socket=%d\n", pSocketData->socketId);
   LOG(" - isConnected=%d", pSocketData->isConnected);
   char *creationTypeMsg;
   switch(pSocketData->creationType) {
@@ -284,6 +308,7 @@ void esp8266_dumpSocket(
     break;
   }
   LOG(", state=%s", stateMsg);
+  LOG(", espconn=0x%x", (unsigned int)pSocketData->pEspconn);
   LOG(", errorCode=%d", pSocketData->errorCode);
 
   // Print the errorMsg if it has anything to say
@@ -481,7 +506,6 @@ static void resetSocketByData(
 
   pSocketData->acceptedSocketsHead = 0; // Set the head to 0
   pSocketData->acceptedSocketsTail = 0; // Set the tail to 9.
-  pSocketData->pEspconn    = NULL;
 }
 
 
@@ -511,9 +535,10 @@ static void releaseSocket(
 
   // If this socket is not an incoming socket that means that the espconn structure was created
   // by us and we should release the storage we allocated.
-  if (pSocketData->creationType != SOCKET_CREATED_INBOUND) {
+  if (pSocketData->creationType != SOCKET_CREATED_INBOUND && pSocketData->creationType != SOCKET_CREATED_SERVER) {
     os_free(pSocketData->pEspconn->proto.tcp);
     pSocketData->pEspconn->proto.tcp = NULL;
+    os_printf(" - freeing espconn: 0x%x\n", (unsigned int)pSocketData->pEspconn);
     os_free(pSocketData->pEspconn);
     pSocketData->pEspconn = NULL;
   }
@@ -556,14 +581,23 @@ static void doClose(
 
   struct socketData *pSocketData = getSocketData(socketId);
 
-  if (pSocketData->state != SOCKET_STATE_CLOSING) {
-    int rc = espconn_disconnect(pSocketData->pEspconn);
+
+  if (pSocketData->creationType == SOCKET_CREATED_SERVER) {
+    int rc = espconn_delete(pSocketData->pEspconn);
+    if (rc != 0) {
+      os_printf("espconn_delete: rc=%s (%d)\n",esp8266_errorToString(rc),  rc);
+      setSocketInError(socketId, "espconn_disconnect", rc);
+    }
     pSocketData->state = SOCKET_STATE_CLOSING;
+  }
 
+  if (pSocketData->state != SOCKET_STATE_CLOSING) {
+    int rc = espconn_disconnect(pSocketData->pEspconn);
     if (rc != 0) {
-      os_printf("espconn_disconnect: rc=%d\n", rc);
+      os_printf("espconn_disconnect: rc=%s (%d)\n",esp8266_errorToString(rc),  rc);
       setSocketInError(socketId, "espconn_disconnect", rc);
     }
+    pSocketData->state = SOCKET_STATE_CLOSING;
   }
   // Our existing state on entry was SOCKET_STATE_CLOSING which means that we got here
   // because we were previously flagged as closing.
@@ -695,6 +729,7 @@ static void esp8266_callback_disconnectCB(
   // If the socket state is SOCKET_STATE_CLOSING then that means we can release the socket.  The reason
   // for this is that the last thing the user did was request an explicit socket close.
   if (pSocketData->state == SOCKET_STATE_CLOSING) {
+
     releaseSocket(pSocketData->socketId);
   } else {
     pSocketData->state       = SOCKET_STATE_CLOSING;
@@ -787,7 +822,7 @@ static void esp8266_callback_recvCB(
   if (pSocketData->rxBufLen == 0) {
     pSocketData->rxBuf = (void *)os_malloc(len);
     if (pSocketData->rxBuf == NULL) {
-      os_printf(" - Out of memory\n");
+      os_printf(" - #1 Out of memory allocating %d\n", len);
       return;
     }
     os_memcpy(pSocketData->rxBuf, pData, len);
@@ -801,7 +836,7 @@ static void esp8266_callback_recvCB(
 // Update the socket data.
     uint8 *pNewBuf = (uint8 *)os_malloc(len + pSocketData->rxBufLen);
     if (pNewBuf == NULL) {
-      os_printf(" - Out of memory\n");
+      os_printf(" - #2 Out of memory allocating %d\n", len + pSocketData->rxBufLen);
       return;
     }
     os_memcpy(pNewBuf, pSocketData->rxBuf, pSocketData->rxBufLen);
@@ -1039,6 +1074,7 @@ int net_ESP8266_BOARD_createSocket(
 
   pSocketData->pEspconn = (struct espconn *)os_malloc(sizeof(struct espconn));
   assert(pSocketData->pEspconn);
+  os_printf(" - espconn: 0x%x\n", (unsigned int)pSocketData->pEspconn);
 
   struct espconn *pEspconn = pSocketData->pEspconn;
 
@@ -1124,7 +1160,7 @@ void net_ESP8266_BOARD_closeSocket(
   //dumpEspConn(pSocketData->pEspconn);
 
   // How we close the socket is a function of what kind of socket it is.
-
+/*
   // Close a server socket
   if (pSocketData->creationType == SOCKET_CREATED_SERVER) {
     int rc = espconn_delete(pSocketData->pEspconn);
@@ -1146,6 +1182,20 @@ void net_ESP8266_BOARD_closeSocket(
       pSocketData->shouldClose = true;
     }
   }
+ */
+
+  // If the state of the socket is idle, closing or error then we can actually close the socket.
+  // If it is not one of these states, then we are in the middle of something so let that
+  // something completed and then we can finish.
+  if (pSocketData->state == SOCKET_STATE_IDLE ||
+    pSocketData->state == SOCKET_STATE_CLOSING ||
+    pSocketData->state == SOCKET_STATE_ERROR) {
+    doClose(socketId);
+  } else {
+    pSocketData->shouldClose = true;
+  }
+
+  os_printf("< net_ESP8266_BOARD_closeSocket\n");
 }
 
 

libs/network/esp8266/network_esp8266.h

@@ -21,6 +21,7 @@
 void netInit_esp8266_board();
 void netSetCallbacks_esp8266_board(JsNetwork *net);
 void esp8266_dumpSocket(int socketId);
+void esp8266_dumpAllSocketData();
 int  net_ESP8266_BOARD_accept(JsNetwork *net, int serverSckt);
 int  net_ESP8266_BOARD_recv(JsNetwork *net, int sckt, void *buf, size_t len);
 int  net_ESP8266_BOARD_send(JsNetwork *net, int sckt, const void *buf, size_t len);