Diff: UIPClient.cpp

Revision:

0:5350a66d5279

Child:

2:049ce85163c5

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/UIPClient.cpp	Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,627 @@
+/*
+ UIPClient.cpp - Arduino implementation of a uIP wrapper class.
+ Copyright (c) 2013 Norbert Truchsess <norbert.truchsess@t-online.de>
+ 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"
+{
+#include "uip-conf.h"
+#include "uip.h"
+#include "uip_arp.h"
+#include "string.h"
+}
+#include "UIPEthernet.h"
+#include "UIPClient.h"
+#include "Dns.h"
+
+#ifdef UIPETHERNET_DEBUG_CLIENT
+    #include "HardwareSerial.h"
+#endif
+#define UIP_TCP_PHYH_LEN    UIP_LLH_LEN + UIP_IPTCPH_LEN
+
+uip_userdata_closed_t* UIPClient::  closed_conns[UIP_CONNS];
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+UIPClient::UIPClient(void) :
+    _uip_conn(NULL),
+    data(NULL) {
+    UIPEthernet.set_uip_callback(&UIPClient::uip_callback);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+UIPClient::UIPClient(struct uip_conn* conn) :
+    _uip_conn(conn),
+    data(conn ? (uip_userdata_t*)conn->appstate.user : NULL)
+{ }
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+UIPClient::UIPClient(uip_userdata_closed_t* conn_data) :
+    _uip_conn(NULL),
+    data((uip_userdata_t*)conn_data)
+{ }
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+int UIPClient::connect(IPAddress ip, uint16_t port) {
+    uip_ipaddr_t    ipaddr;
+    uip_ip_addr(ipaddr, ip);
+    _uip_conn = uip_connect(&ipaddr, htons(port));
+    if(_uip_conn) {
+        while((_uip_conn->tcpstateflags & UIP_TS_MASK) != UIP_CLOSED) {
+            UIPEthernet.tick();
+            if((_uip_conn->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED)
+            {
+#ifdef UIPETHERNET_DEBUG_CLIENT
+                Serial.print("connected, state: ");
+                Serial.print(((uip_userdata_t*)_uip_conn->appstate.user)->state);
+                Serial.print(", first packet in: ");
+                Serial.println(((uip_userdata_t*)_uip_conn->appstate.user)->packets_in[0]);
+#endif
+                return 1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+int UIPClient::connect(const char* host, uint16_t port) {
+
+    // Look up the host first
+    int         ret = 0;
+#if UIP_UDP
+    DNSClient   dns;
+    IPAddress   remote_addr;
+
+    dns.begin(UIPEthernet.dnsServerIP());
+    ret = dns.getHostByName(host, remote_addr);
+    if(ret == 1) {
+        return connect(remote_addr, port);
+    }
+#endif
+    return ret;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPClient::stop(void) {
+    if(data) {
+        _flushBlocks(&data->packets_in[0]);
+        if(data->state & UIP_CLIENT_CLOSED) {
+            uip_userdata_closed_t **     cc = &UIPClient::closed_conns[0];
+            for(uint8_t i = 0; i < UIP_CONNS; i++) {
+                if(*cc == (void*)data) {
+                    *cc = NULL;
+                    break;
+                }
+
+                cc++;
+            }
+
+            free(data);
+        }
+        else {
+            data->state |= UIP_CLIENT_CLOSE;
+        }
+
+        data = NULL;
+    }
+
+    _uip_conn = NULL;
+    UIPEthernet.tick();
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+uint8_t UIPClient::connected(void) {
+    return((_uip_conn && (_uip_conn->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED) || available() > 0) ? 1 : 0;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+bool UIPClient::operator==(const UIPClient& rhs) {
+    return _uip_conn && rhs._uip_conn && _uip_conn == rhs._uip_conn;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+UIPClient::operator bool(void) {
+    UIPEthernet.tick();
+    return(data || (_uip_conn && (data = (uip_userdata_t*)_uip_conn->appstate.user)))
+&&  (!(data->state & UIP_CLIENT_CLOSED) || data->packets_in[0] != NOBLOCK);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+size_t UIPClient::write(uint8_t c) {
+    return _write(_uip_conn, &c, 1);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+size_t UIPClient::write(const uint8_t* buf, size_t size) {
+    return _write(_uip_conn, buf, size);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+size_t UIPClient::_write(struct uip_conn* conn, const uint8_t* buf, size_t size) {
+    uip_userdata_t*     u;
+    int                 remain = size;
+    uint16_t            written;
+#if UIP_ATTEMPTS_ON_WRITE > 0
+    uint16_t            attempts = UIP_ATTEMPTS_ON_WRITE;
+#endif
+    repeat : UIPEthernet.tick();
+    if(conn && (u = (uip_userdata_t*)conn->appstate.user) && !(u->state & (UIP_CLIENT_CLOSE | UIP_CLIENT_CLOSED))) {
+        memhandle*  p = _currentBlock(&u->packets_out[0]);
+        if(*p == NOBLOCK)
+        {
+newpacket:
+            *p = UIPEthernet.network.allocBlock(UIP_SOCKET_DATALEN);
+            if(*p == NOBLOCK)
+            {
+#if UIP_ATTEMPTS_ON_WRITE > 0
+                if((--attempts) > 0)
+#endif
+#if UIP_ATTEMPTS_ON_WRITE != 0
+                    goto repeat;
+#endif
+                goto ready;
+            }
+
+            u->out_pos = 0;
+        }
+
+#ifdef UIPETHERNET_DEBUG_CLIENT
+        Serial.print("UIPClient.write: writePacket(");
+        Serial.print(*p);
+        Serial.print(") pos: ");
+        Serial.print(u->out_pos);
+        Serial.print(", buf[");
+        Serial.print(size - remain);
+        Serial.print("-");
+        Serial.print(remain);
+        Serial.print("]: '");
+        Serial.write((uint8_t*)buf + size - remain, remain);
+        Serial.println("'");
+#endif
+        written = UIPEthernet.network.writePacket(*p, u->out_pos, (uint8_t*)buf + size - remain, remain);
+        remain -= written;
+        u->out_pos += written;
+        if(remain > 0) {
+            if(p == &u->packets_out[UIP_SOCKET_NUMPACKETS - 1])
+            {
+#if UIP_ATTEMPTS_ON_WRITE > 0
+                if((--attempts) > 0)
+#endif
+#if UIP_ATTEMPTS_ON_WRITE != 0
+                    goto repeat;
+#endif
+                goto ready;
+            }
+
+            p++;
+            goto newpacket;
+        }
+
+ready:
+        return size - remain;
+    }
+
+    return -1;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+int UIPClient::available(void) {
+    if(*this)
+        return _available(data);
+    return -1;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+int UIPClient::_available(uip_userdata_t* u) {
+    memhandle*  p = &u->packets_in[0];
+    if(*p == NOBLOCK)
+        return 0;
+
+    int len = 0;
+    for(memhandle * end = p + UIP_SOCKET_NUMPACKETS; p < end; p++) {
+        if(*p == NOBLOCK)
+            break;
+        len += UIPEthernet.network.blockSize(*p);
+    }
+
+    return len;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+int UIPClient::read(uint8_t* buf, size_t size) {
+    if(*this) {
+        int         remain = size;
+        memhandle*  p = &data->packets_in[0];
+        if(*p == NOBLOCK)
+            return 0;
+
+        int read;
+        do
+        {
+            read = UIPEthernet.network.readPacket(*p, 0, buf + size - remain, remain);
+            if(read == UIPEthernet.network.blockSize(*p)) {
+                remain -= read;
+                _eatBlock(p);
+                if(_uip_conn && uip_stopped(_uip_conn) && !(data->state & (UIP_CLIENT_CLOSE | UIP_CLIENT_CLOSED)))
+                    data->state |= UIP_CLIENT_RESTART;
+                if(*p == NOBLOCK)
+                    return size - remain;
+            }
+            else {
+                UIPEthernet.network.resizeBlock(*p, read);
+                break;
+            }
+        } while(remain > 0);
+        return size;
+    }
+
+    return -1;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+int UIPClient::read(void) {
+    uint8_t c;
+    if(read(&c, 1) < 0)
+        return -1;
+    return c;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+int UIPClient::peek(void) {
+    if(*this) {
+        memhandle   p = data->packets_in[0];
+        if(p != NOBLOCK) {
+            uint8_t c;
+            UIPEthernet.network.readPacket(p, 0, &c, 1);
+            return c;
+        }
+    }
+
+    return -1;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPClient::flush(void) {
+    if(*this) {
+        _flushBlocks(&data->packets_in[0]);
+    }
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPClient::uip_callback(uip_tcp_appstate_t* s) {
+    uip_userdata_t*     u = (uip_userdata_t*)s->user;
+    if(!u && uip_connected())
+    {
+#ifdef UIPETHERNET_DEBUG_CLIENT
+        Serial.println("UIPClient uip_connected");
+#endif
+        // We want to store some data in our connections, so allocate some space
+
+        // for it.  The connection_data struct is defined in a separate .h file,
+        // due to the way the Arduino IDE works.  (typedefs come after function
+        // definitions.)
+        u = (uip_userdata_t*)malloc(sizeof(uip_userdata_t));
+        if(u) {
+            memset(u, 0, sizeof(uip_userdata_t));
+            s->user = u;
+        }
+    }
+
+    if(u) {
+        if(uip_newdata())
+        {
+#ifdef UIPETHERNET_DEBUG_CLIENT
+            Serial.print("UIPClient uip_newdata, uip_len:");
+            Serial.println(uip_len);
+#endif
+            if(uip_len && !(u->state & (UIP_CLIENT_CLOSE | UIP_CLIENT_CLOSED))) {
+                memhandle   newPacket = UIPEthernet.network.allocBlock(uip_len);
+                if(newPacket != NOBLOCK) {
+                    memhandle*  p = _currentBlock(&u->packets_in[0]);
+                    //if it's not the first packet
+
+                    if(*p != NOBLOCK) {
+                        uint8_t slot = p - &u->packets_in[0];
+                        if(slot < UIP_SOCKET_NUMPACKETS - 1)
+                            p++;
+
+                        //if this is the last slot stop this connection
+                        if(slot >= UIP_SOCKET_NUMPACKETS - 2) {
+                            uip_stop();
+
+                            //if there's no free slot left omit loosing this packet and (again) stop this connection
+                            if(slot == UIP_SOCKET_NUMPACKETS - 1)
+                                goto reject_newdata;
+                        }
+                    }
+
+                    UIPEthernet.network.copyPacket
+                        (
+                            newPacket,
+                            0,
+                            UIPEthernet.in_packet,
+                            ((uint8_t*)uip_appdata) - uip_buf,
+                            uip_len
+                        );
+                    *p = newPacket;
+                    goto finish_newdata;
+                }
+
+reject_newdata:
+                UIPEthernet.packetstate &= ~UIPETHERNET_FREEPACKET;
+                uip_stop();
+            }
+        }
+
+finish_newdata:
+        if(u->state & UIP_CLIENT_RESTART) {
+            u->state &= ~UIP_CLIENT_RESTART;
+            uip_restart();
+        }
+
+        // If the connection has been closed, save received but unread data.
+        if(uip_closed() || uip_timedout())
+        {
+#ifdef UIPETHERNET_DEBUG_CLIENT
+            Serial.println("UIPClient uip_closed");
+#endif
+            // drop outgoing packets not sent yet:
+
+            _flushBlocks(&u->packets_out[0]);
+            if(u->packets_in[0] != NOBLOCK) {
+                uip_userdata_closed_t **     closed_conn_data = &UIPClient::closed_conns[0];
+                for(uip_socket_ptr i = 0; i < UIP_CONNS; i++) {
+                    if(!*closed_conn_data) {
+                        *closed_conn_data = (uip_userdata_closed_t*)u;
+                        (*closed_conn_data)->lport = uip_conn->lport;
+                        break;
+                    }
+
+                    closed_conn_data++;
+                }
+            }
+
+            u->state |= UIP_CLIENT_CLOSED;
+
+            // disassociate appdata.
+            s->user = NULL;
+            goto nodata;
+        }
+
+        if(uip_acked())
+        {
+#ifdef UIPETHERNET_DEBUG_CLIENT
+            Serial.println("UIPClient uip_acked");
+#endif
+            _eatBlock(&u->packets_out[0]);
+        }
+
+        if(uip_poll() || uip_rexmit())
+        {
+#ifdef UIPETHERNET_DEBUG_CLIENT
+            Serial.println("UIPClient uip_poll");
+#endif
+
+            memhandle   p = u->packets_out[0];
+            if(p != NOBLOCK) {
+                if(u->packets_out[1] == NOBLOCK) {
+                    uip_len = u->out_pos;
+                    if(uip_len > 0) {
+                        UIPEthernet.network.resizeBlock(p, 0, uip_len);
+                    }
+                }
+                else
+                    uip_len = UIPEthernet.network.blockSize(p);
+                if(uip_len > 0) {
+                    UIPEthernet.uip_hdrlen = ((uint8_t*)uip_appdata) - uip_buf;
+                    UIPEthernet.uip_packet = UIPEthernet.network.allocBlock(UIPEthernet.uip_hdrlen + uip_len);
+                    if(UIPEthernet.uip_packet != NOBLOCK) {
+                        UIPEthernet.network.copyPacket(UIPEthernet.uip_packet, UIPEthernet.uip_hdrlen, p, 0, uip_len);
+                        UIPEthernet.packetstate |= UIPETHERNET_SENDPACKET;
+                        uip_send(uip_appdata, uip_len);
+                    }
+
+                    return;
+                }
+            }
+        }
+
+        // don't close connection unless all outgoing packets are sent
+        if(u->state & UIP_CLIENT_CLOSE)
+        {
+#ifdef UIPETHERNET_DEBUG_CLIENT
+            Serial.print("UIPClient state UIP_CLIENT_CLOSE");
+#endif
+            if(u->packets_out[0] == NOBLOCK)
+            {
+#ifdef UIPETHERNET_DEBUG_CLIENT
+                Serial.print("UIPClient state UIP_CLIENT_CLOSE -> free userdata");
+#endif
+                free(u);
+                s->user = NULL;
+                uip_close();
+            }
+            else
+                uip_stop();
+        }
+    }
+
+nodata:
+    UIPEthernet.uip_packet = NOBLOCK;
+    uip_len = 0;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+memhandle* UIPClient::_currentBlock(memhandle* block) {
+    for(memhandle * end = block + UIP_SOCKET_NUMPACKETS - 1; block < end; block++)
+        if(*(block + 1) == NOBLOCK)
+            break;
+    return block;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPClient::_eatBlock(memhandle* block)
+{
+#ifdef UIPETHERNET_DEBUG_CLIENT
+    memhandle*  start = block;
+    Serial.print("eatblock(");
+    Serial.print(*block);
+    Serial.print("): ");
+    for(uint8_t i = 0; i < UIP_SOCKET_NUMPACKETS; i++) {
+        Serial.print(start[i]);
+        Serial.print(" ");
+    }
+
+    Serial.print("-> ");
+#endif
+
+    memhandle*  end = block + (UIP_SOCKET_NUMPACKETS - 1);
+    UIPEthernet.network.freeBlock(*block);
+    while(block < end)
+        *block = *((block++) + 1);
+    *end = NOBLOCK;
+#ifdef UIPETHERNET_DEBUG_CLIENT
+    for(uint8_t i = 0; i < UIP_SOCKET_NUMPACKETS; i++) {
+        Serial.print(start[i]);
+        Serial.print(" ");
+    }
+
+    Serial.println();
+#endif
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPClient::_flushBlocks(memhandle* block) {
+    for(memhandle * end = block + UIP_SOCKET_NUMPACKETS; block < end; block++) {
+        if(*block != NOBLOCK) {
+            UIPEthernet.network.freeBlock(*block);
+            *block = NOBLOCK;
+        }
+        else
+            break;
+    }
+}