add UIPClientExt with nonblocking connect

Author: ntruchsess

UIPClient.h

@@ -98,9 +98,22 @@ class UIPClient : public Client {
 
   friend class UIPEthernetClass;
   friend class UIPServer;
+  friend class UIPClientExt;
 
   friend void uipclient_appcall(void);
+};
+
+class UIPClientExt : public UIPClient {
+
+public:
+  UIPClientExt();
+  int connectNB(IPAddress ip, uint16_t port);
+  void stop();
+  uint8_t connected();
+  operator bool();
 
+private:
+  struct uip_conn* conn;
 };
 
 #endif

UIPClientExt.cpp

@@ -0,0 +1,87 @@
+/*
+ UIPClient.cpp - Arduino implementation of a uIP wrapper class.
+ Copyright (c) 2013 Norbert Truchsess <[email protected]>
+ All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+extern "C"
+{
+#import "utility/uip-conf.h"
+#import "utility/uip.h"
+#import "utility/uip_arp.h"
+#import "string.h"
+}
+#include "UIPEthernet.h"
+#include "UIPClient.h"
+#include "Dns.h"
+
+#ifdef UIPETHERNET_DEBUG_CLIENT
+#include "HardwareSerial.h"
+#endif
+
+UIPClientExt::UIPClientExt() :
+    conn(NULL)
+{
+  UIPClient();
+}
+
+int
+UIPClientExt::connectNB(IPAddress ip, uint16_t port)
+{
+    stop();
+    uip_ipaddr_t ipaddr;
+    uip_ip_addr(ipaddr, ip);
+    conn = uip_connect(&ipaddr, htons(port));
+    return conn ? 1 : 0;
+}
+
+void
+UIPClientExt::stop()
+{
+  if (!data && conn)
+    conn->tcpstateflags = UIP_CLOSED;
+  else
+    {
+      conn = NULL;
+      UIPClient::stop();
+    }
+}
+
+uint8_t
+UIPClientExt::connected()
+{
+  return this ? UIPClient::connected() : 0;
+}
+
+UIPClientExt::operator bool()
+{
+  UIPEthernetClass::tick();
+  if (conn && !data && (conn->tcpstateflags & UIP_TS_MASK) != UIP_CLOSED)
+    {
+      if ((conn->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED)
+        {
+          data = (uip_userdata_t*) conn->appstate;
+#ifdef UIPETHERNET_DEBUG_CLIENT
+          Serial.print(F("connected, state: "));
+          Serial.print(data->state);
+          Serial.print(F(", first packet in: "));
+          Serial.println(data->packets_in[0]);
+#endif
+        }
+      return true;
+    }
+  return data && (!(data->state & UIP_CLIENT_REMOTECLOSED) || data->packets_in[0] != NOBLOCK);
+}

UIPEthernet.h

@@ -102,6 +102,7 @@ class UIPEthernetClass
   friend class UIPServer;
 
   friend class UIPClient;
+  friend class UIPClientExt;
 
   friend class UIPUDP;
 

examples/NonBlockingTcpClient/NonBlockingTcpClient.ino

@@ -0,0 +1,109 @@
+/*
+ * UIPEthernet NonBlockingTcpClient example.
+ *
+ * UIPEthernet is a TCP/IP stack that can be used with a enc28j60 based
+ * Ethernet-shield.
+ *
+ * UIPEthernet uses the fine uIP stack by Adam Dunkels <[email protected]>
+ *
+ *      -----------------
+ *
+ * This NonBlockingTcpClient example gets its local ip-address via dhcp and
+ * attempts to connect via tcp socket-connection to 192.168.0.1 port 5000.
+ * After initiating the connection it waits for up to 5 seconds for the
+ * connection to be established.
+ * If connected successfully it sends a message and waits for a response.
+ * After receiving the response the client disconnects and tries to reconnect
+ * after 5 seconds.
+ * If the connection-attempt does not succeed within 5 seconds the connection
+ * is cleaned up (calling stop()).
+ *
+ * Copyright (C) 2013 by Norbert Truchsess <[email protected]>
+ */
+
+#include <UIPEthernet.h>
+
+UIPClientExt client;
+signed long next;
+
+void setup() {
+
+  Serial.begin(9600);
+
+  uint8_t mac[6] = {0x00,0x01,0x02,0x03,0x04,0x05};
+  Ethernet.begin(mac);
+
+  Serial.print(F("localIP: "));
+  Serial.println(Ethernet.localIP());
+  Serial.print(F("subnetMask: "));
+  Serial.println(Ethernet.subnetMask());
+  Serial.print(F("gatewayIP: "));
+  Serial.println(Ethernet.gatewayIP());
+  Serial.print(F("dnsServerIP: "));
+  Serial.println(Ethernet.dnsServerIP());
+
+  next = 0;
+}
+
+void loop() {
+
+  if (((signed long)(millis() - next)) > 0)
+    {
+      next = millis() + 5000;
+      Serial.println(F("Client connect"));
+      // connectNB returns without waiting for the connection to be established (non-blocking behaviour)
+      if (client.connectNB(IPAddress(192,168,0,1),5000))
+        {
+          Serial.println(F("waiting for connection to be established"));
+          // as long the connection is being established the boolean operator of client returns true,
+          // but client.connected() return false (0).
+          do
+            {
+              if (!client)
+                {
+                  Serial.println(F("connection refused"));
+                  break;
+                }
+              if (client.connected())
+                {
+                  Serial.println(F("Client connected"));
+                  break;
+                }
+              if ((signed long)(millis() - next) > 0)
+                {
+                  Serial.println(F("timed out"));
+                  break;
+                }
+            }
+          while (true);
+
+          if (client.connected())
+            {
+             client.println(F("DATA from Client"));
+              while(client.available()==0)
+                {
+                  if (next - millis() < 0)
+                    goto close;
+                }
+              int size;
+              while((size = client.available()) > 0)
+                {
+                  uint8_t* msg = (uint8_t*)malloc(size);
+                  size = client.read(msg,size);
+                  Serial.write(msg,size);
+                  free(msg);
+                }
+    close:
+              //disconnect client
+              Serial.println(F("Client disconnect"));
+              client.stop();
+            }
+          else
+            {
+              Serial.println(F("Client connect failed"));
+            }
+        }
+      else
+        Serial.println(F("Client connect failed"));
+    }
+}