Zoltan Hudak
Mbed library for ENC28J60 Ethernet modules. Full support for TCP/IP and UDP Server, Client and HTTP server (webserver). DHCP and DNS is included.
Dependents: mBuino_ENC28_MQTT Nucleo_Web_ENC28J60 Nucleo_Web_ENC28J60_ADC Serial_over_Ethernet ... more
Library for ENC28J60 Ethernet modules.
Ported to mbed from Norbert Truchsess's UIPEthernet library for Arduino. Thank you Norbert!
- Full support for persistent (streaming) TCP/IP and UDP connections Client and Server each, ARP, ICMP, DHCP and DNS.
- Works with both Mbed OS 2 and Mbed OS 5.
Usage:
- Import the library into your project.
- Add
#include "UipEthernet.h"tomain.cpp - Create one instance of the UipEthernet class initialized with the MAC address you'd like to use and SPI pins of the connected Mbed board.
Example programs:
Import programWebSwitch_ENC28J60
HTTP Server serving a simple webpage which enables to remotely turn a digital output on/off. Compile, download, run and type 'IP_address/secret/' (don't forget the last '/') into your web browser and hit ENTER.
Last commit 23 Jul 2020 by 
Zoltan Hudak
Import programHTTPServer_Echo_ENC28J60
A simple HTTP server echoing received requests. Ethernet connection is over an ENC28J60 board. Usage: Type the server's IP address into you web browser and hit <ENTER>.
Last commit 23 Jul 2020 by Zoltan Hudak
Import programTcpServer_ENC28J60
Simple TCP/IP Server using the UIPEthernet library for ENC28J60 Ethernet boards.
Last commit 23 Jul 2020 by Zoltan Hudak
Import programTcpClient_ENC28J60
Simple TCP/IP Client using the UIPEthernet library for ENC28J60 Ethernet boards.
Last commit 23 Jul 2020 by Zoltan Hudak
Import programUdpServer_ENC28J60
Simple UDP Server using the UIPEthernet library for ENC28J60 Ethernet boards.
Last commit 23 Jul 2020 by Zoltan Hudak
Import programUdpClient_ENC28J60
Simple UDP Client using the UIPEthernet library for ENC28J60 Ethernet boards.
Last commit 23 Jul 2020 by Zoltan Hudak
Import programMQTT_Hello_ENC28J60
MQTT Client example program. Ethernet connection is via an ENC28J60 module.
Last commit 23 Jul 2020 by Zoltan Hudak
Revision 0:5350a66d5279, committed 2014-09-15
- Comitter:
- hudakz
- Date:
- Mon Sep 15 11:12:30 2014 +0000
- Child:
- 1:01c2344f98a3
- Commit message:
- rev. 00
Changed in this revision
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Dhcp.cpp Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,538 @@
+// DHCP Library v0.3 - April 25, 2009
+// Author: Jordan Terrell - blog.jordanterrell.com
+#include <string.h>
+#include <stdlib.h>
+#include "Dhcp.h"
+#include "util.h"
+#include "uip_clock.h"
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+int DhcpClass::beginWithDHCP(uint8_t* mac, unsigned long timeout, unsigned long responseTimeout) {
+ _dhcpLeaseTime = 0;
+ _dhcpT1 = 0;
+ _dhcpT2 = 0;
+ _lastCheck = 0;
+ _timeout = timeout;
+ _responseTimeout = responseTimeout;
+
+ // zero out _dhcpMacAddr
+ memset(_dhcpMacAddr, 0, 6);
+ reset_DHCP_lease();
+
+ memcpy((void*)_dhcpMacAddr, (void*)mac, 6);
+ _dhcp_state = STATE_DHCP_START;
+ return request_DHCP_lease();
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void DhcpClass::reset_DHCP_lease(void) {
+
+ // zero out _dhcpSubnetMask, _dhcpGatewayIp, _dhcpLocalIp, _dhcpDhcpServerIp, _dhcpDnsServerIp
+
+ memset(_dhcpLocalIp, 0, 20);
+}
+
+//return:0 on error, 1 if request is sent and response is received
+int DhcpClass::request_DHCP_lease(void) {
+ uint8_t messageType = 0;
+
+ // Pick an initial transaction ID
+
+ _dhcpTransactionId = (rand() * 2000UL) / RAND_MAX + 1;
+ _dhcpInitialTransactionId = _dhcpTransactionId;
+
+ _dhcpUdpSocket.stop();
+ if(_dhcpUdpSocket.begin(DHCP_CLIENT_PORT) == 0) {
+
+ // Couldn't get a socket
+ return 0;
+ }
+
+ presend_DHCP();
+
+ int result = 0;
+
+ unsigned long startTime = clock_time();
+
+ while(_dhcp_state != STATE_DHCP_LEASED) {
+ if(_dhcp_state == STATE_DHCP_START) {
+ _dhcpTransactionId++;
+
+ send_DHCP_MESSAGE(DHCP_DISCOVER, ((clock_time() - startTime) / 1000));
+ _dhcp_state = STATE_DHCP_DISCOVER;
+ }
+ else
+ if(_dhcp_state == STATE_DHCP_REREQUEST) {
+ _dhcpTransactionId++;
+ send_DHCP_MESSAGE(DHCP_REQUEST, ((clock_time() - startTime) / 1000));
+ _dhcp_state = STATE_DHCP_REQUEST;
+ }
+ else
+ if(_dhcp_state == STATE_DHCP_DISCOVER) {
+ uint32_t respId;
+ messageType = parseDHCPResponse(_responseTimeout, respId);
+ if(messageType == DHCP_OFFER) {
+
+ // We'll use the transaction ID that the offer came with,
+ // rather than the one we were up to
+ _dhcpTransactionId = respId;
+ send_DHCP_MESSAGE(DHCP_REQUEST, ((clock_time() - startTime) / 1000));
+ _dhcp_state = STATE_DHCP_REQUEST;
+ }
+ }
+ else
+ if(_dhcp_state == STATE_DHCP_REQUEST) {
+ uint32_t respId;
+ messageType = parseDHCPResponse(_responseTimeout, respId);
+ if(messageType == DHCP_ACK) {
+ _dhcp_state = STATE_DHCP_LEASED;
+ result = 1;
+
+ //use default lease time if we didn't get it
+ if(_dhcpLeaseTime == 0) {
+ _dhcpLeaseTime = DEFAULT_LEASE;
+ }
+
+ //calculate T1 & T2 if we didn't get it
+ if(_dhcpT1 == 0) {
+
+ //T1 should be 50% of _dhcpLeaseTime
+ _dhcpT1 = _dhcpLeaseTime >> 1;
+ }
+
+ if(_dhcpT2 == 0) {
+
+ //T2 should be 87.5% (7/8ths) of _dhcpLeaseTime
+ _dhcpT2 = _dhcpT1 << 1;
+ }
+
+ _renewInSec = _dhcpT1;
+ _rebindInSec = _dhcpT2;
+ }
+ else
+ if(messageType == DHCP_NAK)
+ _dhcp_state = STATE_DHCP_START;
+ }
+
+ if(messageType == 255) {
+ messageType = 0;
+ _dhcp_state = STATE_DHCP_START;
+ }
+
+ if(result != 1 && ((clock_time() - startTime) > _timeout))
+ break;
+ }
+
+ // We're done with the socket now
+ _dhcpUdpSocket.stop();
+ _dhcpTransactionId++;
+
+ return result;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void DhcpClass::presend_DHCP(void)
+{ }
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void DhcpClass::send_DHCP_MESSAGE(uint8_t messageType, uint16_t secondsElapsed) {
+ uint8_t buffer[32];
+ memset(buffer, 0, 32);
+
+ IPAddress dest_addr(255, 255, 255, 255); // Broadcast address
+
+ if(-1 == _dhcpUdpSocket.beginPacket(dest_addr, DHCP_SERVER_PORT)) {
+
+ // FIXME Need to return errors
+ return;
+ }
+
+ buffer[0] = DHCP_BOOTREQUEST; // op
+ buffer[1] = DHCP_HTYPE10MB; // htype
+ buffer[2] = DHCP_HLENETHERNET; // hlen
+ buffer[3] = DHCP_HOPS; // hops
+
+ // xid
+ unsigned long xid = htonl(_dhcpTransactionId);
+ memcpy(buffer + 4, &(xid), 4);
+
+ // 8, 9 - seconds elapsed
+ buffer[8] = ((secondsElapsed & 0xff00) >> 8);
+ buffer[9] = (secondsElapsed & 0x00ff);
+
+ // flags
+ unsigned short flags = htons(DHCP_FLAGSBROADCAST);
+ memcpy(buffer + 10, &(flags), 2);
+
+ // ciaddr: already zeroed
+ // yiaddr: already zeroed
+ // siaddr: already zeroed
+ // giaddr: already zeroed
+ //put data in W5100 transmit buffer
+ _dhcpUdpSocket.write(buffer, 28);
+
+ memset(buffer, 0, 32); // clear local buffer
+ memcpy(buffer, _dhcpMacAddr, 6); // chaddr
+
+ //put data in W5100 transmit buffer
+ _dhcpUdpSocket.write(buffer, 16);
+
+ memset(buffer, 0, 32); // clear local buffer
+
+ // leave zeroed out for sname && file
+ // put in W5100 transmit buffer x 6 (192 bytes)
+ for(int i = 0; i < 6; i++) {
+ _dhcpUdpSocket.write(buffer, 32);
+ }
+
+ // OPT - Magic Cookie
+ buffer[0] = (uint8_t) ((MAGIC_COOKIE >> 24) & 0xFF);
+ buffer[1] = (uint8_t) ((MAGIC_COOKIE >> 16) & 0xFF);
+ buffer[2] = (uint8_t) ((MAGIC_COOKIE >> 8) & 0xFF);
+ buffer[3] = (uint8_t) (MAGIC_COOKIE & 0xFF);
+
+ // OPT - message type
+ buffer[4] = dhcpMessageType;
+ buffer[5] = 0x01;
+ buffer[6] = messageType; //DHCP_REQUEST;
+
+ // OPT - client identifier
+ buffer[7] = dhcpClientIdentifier;
+ buffer[8] = 0x07;
+ buffer[9] = 0x01;
+ memcpy(buffer + 10, _dhcpMacAddr, 6);
+
+ // OPT - host name
+ buffer[16] = hostName;
+ buffer[17] = strlen(HOST_NAME) + 6; // length of hostname + last 3 bytes of mac address
+ strcpy((char*) &(buffer[18]), HOST_NAME);
+
+ printByte((char*) &(buffer[24]), _dhcpMacAddr[3]);
+ printByte((char*) &(buffer[26]), _dhcpMacAddr[4]);
+ printByte((char*) &(buffer[28]), _dhcpMacAddr[5]);
+
+ //put data in W5100 transmit buffer
+ _dhcpUdpSocket.write(buffer, 30);
+
+ if(messageType == DHCP_REQUEST) {
+ buffer[0] = dhcpRequestedIPaddr;
+ buffer[1] = 0x04;
+ buffer[2] = _dhcpLocalIp[0];
+ buffer[3] = _dhcpLocalIp[1];
+ buffer[4] = _dhcpLocalIp[2];
+ buffer[5] = _dhcpLocalIp[3];
+
+ buffer[6] = dhcpServerIdentifier;
+ buffer[7] = 0x04;
+ buffer[8] = _dhcpDhcpServerIp[0];
+ buffer[9] = _dhcpDhcpServerIp[1];
+ buffer[10] = _dhcpDhcpServerIp[2];
+ buffer[11] = _dhcpDhcpServerIp[3];
+
+ //put data in W5100 transmit buffer
+ _dhcpUdpSocket.write(buffer, 12);
+ }
+
+ buffer[0] = dhcpParamRequest;
+ buffer[1] = 0x06;
+ buffer[2] = subnetMask;
+ buffer[3] = routersOnSubnet;
+ buffer[4] = dns;
+ buffer[5] = domainName;
+ buffer[6] = dhcpT1value;
+ buffer[7] = dhcpT2value;
+ buffer[8] = endOption;
+
+ //put data in W5100 transmit buffer
+ _dhcpUdpSocket.write(buffer, 9);
+
+ _dhcpUdpSocket.endPacket();
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+uint8_t DhcpClass::parseDHCPResponse(unsigned long responseTimeout, uint32_t& transactionId) {
+ uint8_t type = 0;
+ uint8_t opt_len = 0;
+
+ unsigned long startTime = clock_time();
+
+ while(_dhcpUdpSocket.parsePacket() <= 0) {
+ if((clock_time() - startTime) > responseTimeout) {
+ return 255;
+ }
+
+ wait(0.050);
+ }
+
+ // start reading in the packet
+ RIP_MSG_FIXED fixedMsg;
+ _dhcpUdpSocket.read((uint8_t*) &fixedMsg, sizeof(RIP_MSG_FIXED));
+
+ if(fixedMsg.op == DHCP_BOOTREPLY && _dhcpUdpSocket.remotePort() == DHCP_SERVER_PORT) {
+ transactionId = ntohl(fixedMsg.xid);
+ if
+ (
+ memcmp(fixedMsg.chaddr, _dhcpMacAddr, 6) != 0
+ || (transactionId < _dhcpInitialTransactionId)
+ || (transactionId > _dhcpTransactionId)
+ ) {
+
+ // Need to read the rest of the packet here regardless
+ _dhcpUdpSocket.flush();
+ return 0;
+ }
+
+ memcpy(_dhcpLocalIp, fixedMsg.yiaddr, 4);
+
+ // Skip to the option part
+ // Doing this a byte at a time so we don't have to put a big buffer
+ // on the stack (as we don't have lots of memory lying around)
+ for(int i = 0; i < (240 - (int)sizeof(RIP_MSG_FIXED)); i++) {
+ _dhcpUdpSocket.read(); // we don't care about the returned byte
+ }
+
+ while(_dhcpUdpSocket.available() > 0) {
+ switch(_dhcpUdpSocket.read()) {
+ case endOption:
+ break;
+
+ case padOption:
+ break;
+
+ case dhcpMessageType:
+ opt_len = _dhcpUdpSocket.read();
+ type = _dhcpUdpSocket.read();
+ break;
+
+ case subnetMask:
+ opt_len = _dhcpUdpSocket.read();
+ _dhcpUdpSocket.read(_dhcpSubnetMask, 4);
+ break;
+
+ case routersOnSubnet:
+ opt_len = _dhcpUdpSocket.read();
+ _dhcpUdpSocket.read(_dhcpGatewayIp, 4);
+ for(int i = 0; i < opt_len - 4; i++) {
+ _dhcpUdpSocket.read();
+ }
+ break;
+
+ case dns:
+ opt_len = _dhcpUdpSocket.read();
+ _dhcpUdpSocket.read(_dhcpDnsServerIp, 4);
+ for(int i = 0; i < opt_len - 4; i++) {
+ _dhcpUdpSocket.read();
+ }
+ break;
+
+ case dhcpServerIdentifier:
+ opt_len = _dhcpUdpSocket.read();
+ if(*((uint32_t*)_dhcpDhcpServerIp) == 0 || IPAddress(_dhcpDhcpServerIp) == _dhcpUdpSocket.remoteIP()) {
+ _dhcpUdpSocket.read(_dhcpDhcpServerIp, sizeof(_dhcpDhcpServerIp));
+ }
+ else {
+
+ // Skip over the rest of this option
+ while(opt_len--) {
+ _dhcpUdpSocket.read();
+ }
+ }
+ break;
+
+ case dhcpT1value:
+ opt_len = _dhcpUdpSocket.read();
+ _dhcpUdpSocket.read((uint8_t*) &_dhcpT1, sizeof(_dhcpT1));
+ _dhcpT1 = ntohl(_dhcpT1);
+ break;
+
+ case dhcpT2value:
+ opt_len = _dhcpUdpSocket.read();
+ _dhcpUdpSocket.read((uint8_t*) &_dhcpT2, sizeof(_dhcpT2));
+ _dhcpT2 = ntohl(_dhcpT2);
+ break;
+
+ case dhcpIPaddrLeaseTime:
+ opt_len = _dhcpUdpSocket.read();
+ _dhcpUdpSocket.read((uint8_t*) &_dhcpLeaseTime, sizeof(_dhcpLeaseTime));
+ _dhcpLeaseTime = ntohl(_dhcpLeaseTime);
+ _renewInSec = _dhcpLeaseTime;
+ break;
+
+ default:
+ opt_len = _dhcpUdpSocket.read();
+
+ // Skip over the rest of this option
+ while(opt_len--) {
+ _dhcpUdpSocket.read();
+ }
+ break;
+ }
+ }
+ }
+
+ // Need to skip to end of the packet regardless here
+ _dhcpUdpSocket.flush();
+
+ return type;
+}
+
+/*
+ returns:
+ 0/DHCP_CHECK_NONE: nothing happened
+ 1/DHCP_CHECK_RENEW_FAIL: renew failed
+ 2/DHCP_CHECK_RENEW_OK: renew success
+ 3/DHCP_CHECK_REBIND_FAIL: rebind fail
+ 4/DHCP_CHECK_REBIND_OK: rebind success
+*/
+int DhcpClass::checkLease(void) {
+
+ //this uses a signed / unsigned trick to deal with millis overflow
+ unsigned long now = clock_time();
+ signed long snow = (long)now;
+ int rc = DHCP_CHECK_NONE;
+ if(_lastCheck != 0) {
+ signed long factor;
+ //calc how many ms past the timeout we are
+
+ factor = snow - (long)_secTimeout;
+
+ //if on or passed the timeout, reduce the counters
+ if(factor >= 0) {
+
+ //next timeout should be now plus 1000 ms minus parts of second in factor
+ _secTimeout = snow + 1000 - factor % 1000;
+
+ //how many seconds late are we, minimum 1
+ factor = factor / 1000 + 1;
+
+ //reduce the counters by that mouch
+ //if we can assume that the cycle time (factor) is fairly constant
+ //and if the remainder is less than cycle time * 2
+ //do it early instead of late
+ if(_renewInSec < factor * 2)
+ _renewInSec = 0;
+ else
+ _renewInSec -= factor;
+
+ if(_rebindInSec < factor * 2)
+ _rebindInSec = 0;
+ else
+ _rebindInSec -= factor;
+ }
+
+ //if we have a lease but should renew, do it
+ if(_dhcp_state == STATE_DHCP_LEASED && _renewInSec <= 0) {
+ _dhcp_state = STATE_DHCP_REREQUEST;
+ rc = 1 + request_DHCP_lease();
+ }
+
+ //if we have a lease or is renewing but should bind, do it
+ if((_dhcp_state == STATE_DHCP_LEASED || _dhcp_state == STATE_DHCP_START) && _rebindInSec <= 0) {
+
+ //this should basically restart completely
+ _dhcp_state = STATE_DHCP_START;
+ reset_DHCP_lease();
+ rc = 3 + request_DHCP_lease();
+ }
+ }
+ else {
+ _secTimeout = snow + 1000;
+ }
+
+ _lastCheck = now;
+ return rc;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+IPAddress DhcpClass::getLocalIp(void) {
+ return IPAddress(_dhcpLocalIp);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+IPAddress DhcpClass::getSubnetMask(void) {
+ return IPAddress(_dhcpSubnetMask);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+IPAddress DhcpClass::getGatewayIp(void) {
+ return IPAddress(_dhcpGatewayIp);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+IPAddress DhcpClass::getDhcpServerIp(void) {
+ return IPAddress(_dhcpDhcpServerIp);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+IPAddress DhcpClass::getDnsServerIp(void) {
+ return IPAddress(_dhcpDnsServerIp);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void DhcpClass::printByte(char* buf, uint8_t n) {
+ char* str = &buf[1];
+ buf[0] = '0';
+ do
+ {
+ unsigned long m = n;
+ n /= 16;
+
+ char c = m - 16 * n;
+ *str-- = c < 10 ? c + '0' : c + 'A' - 10;
+ } while(n);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Dhcp.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,189 @@
+// DHCP Library v0.3 - April 25, 2009
+// Author: Jordan Terrell - blog.jordanterrell.com
+#ifndef Dhcp_h
+ #define Dhcp_h
+
+ #include "UIPUdp.h"
+
+/* DHCP state machine. */
+
+ #define STATE_DHCP_START 0
+ #define STATE_DHCP_DISCOVER 1
+ #define STATE_DHCP_REQUEST 2
+ #define STATE_DHCP_LEASED 3
+ #define STATE_DHCP_REREQUEST 4
+ #define STATE_DHCP_RELEASE 5
+
+ #define DHCP_FLAGSBROADCAST 0x8000
+
+/* UDP port numbers for DHCP */
+
+ #define DHCP_SERVER_PORT 67 /* from server to client */
+
+ #define DHCP_CLIENT_PORT 68 /* from client to server */
+
+/* DHCP message OP code */
+
+ #define DHCP_BOOTREQUEST 1
+ #define DHCP_BOOTREPLY 2
+
+/* DHCP message type */
+
+ #define DHCP_DISCOVER 1
+ #define DHCP_OFFER 2
+ #define DHCP_REQUEST 3
+ #define DHCP_DECLINE 4
+ #define DHCP_ACK 5
+ #define DHCP_NAK 6
+ #define DHCP_RELEASE 7
+ #define DHCP_INFORM 8
+
+ #define DHCP_HTYPE10MB 1
+ #define DHCP_HTYPE100MB 2
+
+ #define DHCP_HLENETHERNET 6
+ #define DHCP_HOPS 0
+ #define DHCP_SECS 0
+
+ #define MAGIC_COOKIE 0x63825363
+ #define MAX_DHCP_OPT 16
+
+ #define HOST_NAME "ENC28J"
+ #define DEFAULT_LEASE (900) //default lease time in seconds
+
+ #define DHCP_CHECK_NONE (0)
+ #define DHCP_CHECK_RENEW_FAIL (1)
+ #define DHCP_CHECK_RENEW_OK (2)
+ #define DHCP_CHECK_REBIND_FAIL (3)
+ #define DHCP_CHECK_REBIND_OK (4)
+
+enum
+{
+ padOption = 0,
+ subnetMask = 1,
+ timerOffset = 2,
+ routersOnSubnet = 3,
+
+ /* timeServer = 4,
+ nameServer = 5,*/
+ dns = 6,
+
+ /*logServer = 7,
+ cookieServer = 8,
+ lprServer = 9,
+ impressServer = 10,
+ resourceLocationServer = 11,*/
+ hostName = 12,
+
+ /*bootFileSize = 13,
+ meritDumpFile = 14,*/
+ domainName = 15,
+
+ /*swapServer = 16,
+ rootPath = 17,
+ extentionsPath = 18,
+ IPforwarding = 19,
+ nonLocalSourceRouting = 20,
+ policyFilter = 21,
+ maxDgramReasmSize = 22,
+ defaultIPTTL = 23,
+ pathMTUagingTimeout = 24,
+ pathMTUplateauTable = 25,
+ ifMTU = 26,
+ allSubnetsLocal = 27,
+ broadcastAddr = 28,
+ performMaskDiscovery = 29,
+ maskSupplier = 30,
+ performRouterDiscovery = 31,
+ routerSolicitationAddr = 32,
+ staticRoute = 33,
+ trailerEncapsulation = 34,
+ arpCacheTimeout = 35,
+ ethernetEncapsulation = 36,
+ tcpDefaultTTL = 37,
+ tcpKeepaliveInterval = 38,
+ tcpKeepaliveGarbage = 39,
+ nisDomainName = 40,
+ nisServers = 41,
+ ntpServers = 42,
+ vendorSpecificInfo = 43,
+ netBIOSnameServer = 44,
+ netBIOSdgramDistServer = 45,
+ netBIOSnodeType = 46,
+ netBIOSscope = 47,
+ xFontServer = 48,
+ xDisplayManager = 49,*/
+ dhcpRequestedIPaddr = 50,
+ dhcpIPaddrLeaseTime = 51,
+
+ /*dhcpOptionOverload = 52,*/
+ dhcpMessageType = 53,
+ dhcpServerIdentifier= 54,
+ dhcpParamRequest = 55,
+
+ /*dhcpMsg = 56,
+ dhcpMaxMsgSize = 57,*/
+ dhcpT1value = 58,
+ dhcpT2value = 59,
+
+ /*dhcpClassIdentifier = 60,*/
+ dhcpClientIdentifier= 61,
+ endOption = 255
+};
+
+typedef struct _RIP_MSG_FIXED
+{
+ uint8_t op;
+ uint8_t htype;
+ uint8_t hlen;
+ uint8_t hops;
+ uint32_t xid;
+ uint16_t secs;
+ uint16_t flags;
+ uint8_t ciaddr[4];
+ uint8_t yiaddr[4];
+ uint8_t siaddr[4];
+ uint8_t giaddr[4];
+ uint8_t chaddr[6];
+} RIP_MSG_FIXED;
+
+class DhcpClass
+{
+private:
+ uint32_t _dhcpInitialTransactionId;
+ uint32_t _dhcpTransactionId;
+ uint8_t _dhcpMacAddr[6];
+ uint8_t _dhcpLocalIp[4];
+ uint8_t _dhcpSubnetMask[4];
+ uint8_t _dhcpGatewayIp[4];
+ uint8_t _dhcpDhcpServerIp[4];
+ uint8_t _dhcpDnsServerIp[4];
+ uint32_t _dhcpLeaseTime;
+ uint32_t _dhcpT1, _dhcpT2;
+ signed long _renewInSec;
+ signed long _rebindInSec;
+ signed long _lastCheck;
+ unsigned long _timeout;
+ unsigned long _responseTimeout;
+ unsigned long _secTimeout;
+ uint8_t _dhcp_state;
+ UIPUDP _dhcpUdpSocket;
+
+ int request_DHCP_lease(void);
+ void reset_DHCP_lease(void);
+ void presend_DHCP(void);
+ void send_DHCP_MESSAGE(uint8_t, uint16_t);
+ void printByte(char* , uint8_t);
+
+ uint8_t parseDHCPResponse(unsigned long responseTimeout, uint32_t& transactionId);
+public:
+ IPAddress getLocalIp(void);
+ IPAddress getSubnetMask(void);
+ IPAddress getGatewayIp(void);
+ IPAddress getDhcpServerIp(void);
+ IPAddress getDnsServerIp(void);
+
+ int beginWithDHCP(uint8_t* , unsigned long timeout = 60000, unsigned long responseTimeout = 4000);
+ int checkLease(void);
+};
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Dns.cpp Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,454 @@
+// mbed DNS client for Enc28J60-based Ethernet shield
+// (c) Copyright 2009-2010 MCQN Ltd.
+// Released under Apache License, version 2.0
+#include "Udp.h"
+#include "util.h"
+
+#include "Dns.h"
+#include <string.h>
+//#include <stdlib.h>
+
+#include "mbed.h"
+#include "uip_clock.h"
+
+#define SOCKET_NONE 255
+// Various flags and header field values for a DNS message
+
+#define UDP_HEADER_SIZE 8
+#define DNS_HEADER_SIZE 12
+#define TTL_SIZE 4
+#define QUERY_FLAG (0)
+#define RESPONSE_FLAG (1 << 15)
+#define QUERY_RESPONSE_MASK (1 << 15)
+#define OPCODE_STANDARD_QUERY (0)
+#define OPCODE_INVERSE_QUERY (1 << 11)
+#define OPCODE_STATUS_REQUEST (2 << 11)
+#define OPCODE_MASK (15 << 11)
+#define AUTHORITATIVE_FLAG (1 << 10)
+#define TRUNCATION_FLAG (1 << 9)
+#define RECURSION_DESIRED_FLAG (1 << 8)
+#define RECURSION_AVAILABLE_FLAG (1 << 7)
+#define RESP_NO_ERROR (0)
+#define RESP_FORMAT_ERROR (1)
+#define RESP_SERVER_FAILURE (2)
+#define RESP_NAME_ERROR (3)
+#define RESP_NOT_IMPLEMENTED (4)
+#define RESP_REFUSED (5)
+#define RESP_MASK (15)
+#define TYPE_A (0x0001)
+#define CLASS_IN (0x0001)
+#define LABEL_COMPRESSION_MASK (0xC0)
+// Port number that DNS servers listen on
+
+#define DNS_PORT 53
+
+// Possible return codes from ProcessResponse
+
+#define SUCCESS 1
+#define TIMED_OUT - 1
+#define INVALID_SERVER - 2
+#define TRUNCATED - 3
+#define INVALID_RESPONSE - 4
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void DNSClient::begin(const IPAddress& aDNSServer) {
+ iDNSServer = aDNSServer;
+ iRequestId = 0;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+int DNSClient::inet_aton(const char* aIPAddrString, IPAddress& aResult) {
+
+ // See if we've been given a valid IP address
+ const char* p = aIPAddrString;
+ while(*p && ((*p == '.') || (*p >= '0') || (*p <= '9'))) {
+ p++;
+ }
+
+ if(*p == '\0') {
+
+ // It's looking promising, we haven't found any invalid characters
+ p = aIPAddrString;
+
+ int segment = 0;
+ int segmentValue = 0;
+ while(*p && (segment < 4)) {
+ if(*p == '.') {
+
+ // We've reached the end of a segment
+ if(segmentValue > 255) {
+
+ // You can't have IP address segments that don't fit in a byte
+ return 0;
+ }
+ else {
+ aResult[segment] = (uint8_t) segmentValue;
+ segment++;
+ segmentValue = 0;
+ }
+ }
+ else {
+
+ // Next digit
+ segmentValue = (segmentValue * 10) + (*p - '0');
+ }
+
+ p++;
+ }
+
+ // We've reached the end of address, but there'll still be the last
+ // segment to deal with
+ if((segmentValue > 255) || (segment > 3)) {
+
+ // You can't have IP address segments that don't fit in a byte,
+ // or more than four segments
+ return 0;
+ }
+ else {
+ aResult[segment] = (uint8_t) segmentValue;
+ return 1;
+ }
+ }
+ else {
+ return 0;
+ }
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+int DNSClient::getHostByName(const char* aHostname, IPAddress& aResult) {
+ int ret = 0;
+
+ // See if it's a numeric IP address
+
+ if(inet_aton(aHostname, aResult)) {
+
+ // It is, our work here is done
+ return 1;
+ }
+
+ // Check we've got a valid DNS server to use
+ if(iDNSServer == INADDR_NONE) {
+ return INVALID_SERVER;
+ }
+
+ // Find a socket to use
+ if(iUdp.begin(1024 + (clock_time() & 0xF)) == 1) {
+
+ // Try up to three times
+ int retries = 0;
+ // while ((retries < 3) && (ret <= 0))
+ {
+ // Send DNS request
+ ret = iUdp.beginPacket(iDNSServer, DNS_PORT);
+ if(ret != 0) {
+
+ // Now output the request data
+ ret = BuildRequest(aHostname);
+ if(ret != 0) {
+
+ // And finally send the request
+ ret = iUdp.endPacket();
+ if(ret != 0) {
+
+ // Now wait for a response
+ int wait_retries = 0;
+ ret = TIMED_OUT;
+ while((wait_retries < 3) && (ret == TIMED_OUT)) {
+ ret = ProcessResponse(5000, aResult);
+ wait_retries++;
+ }
+ }
+ }
+ }
+
+ retries++;
+ }
+
+ // We're done with the socket now
+ iUdp.stop();
+ }
+
+ return ret;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+uint16_t DNSClient::BuildRequest(const char* aName) {
+
+ // Build header
+
+ // 1 1 1 1 1 1
+ // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+ // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+ // | ID |
+ // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+ // |QR| Opcode |AA|TC|RD|RA| Z | RCODE |
+ // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+ // | QDCOUNT |
+ // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+ // | ANCOUNT |
+ // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+ // | NSCOUNT |
+ // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+ // | ARCOUNT |
+ // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+ // As we only support one request at a time at present, we can simplify
+ // some of this header
+ iRequestId = clock_time(); // generate a random ID
+ uint16_t twoByteBuffer;
+
+ // FIXME We should also check that there's enough space available to write to, rather
+
+ // FIXME than assume there's enough space (as the code does at present)
+ iUdp.write((uint8_t*) &iRequestId, sizeof(iRequestId));
+
+ twoByteBuffer = htons(QUERY_FLAG | OPCODE_STANDARD_QUERY | RECURSION_DESIRED_FLAG);
+ iUdp.write((uint8_t*) &twoByteBuffer, sizeof(twoByteBuffer));
+
+ twoByteBuffer = htons(1); // One question record
+ iUdp.write((uint8_t*) &twoByteBuffer, sizeof(twoByteBuffer));
+
+ twoByteBuffer = 0; // Zero answer records
+ iUdp.write((uint8_t*) &twoByteBuffer, sizeof(twoByteBuffer));
+
+ iUdp.write((uint8_t*) &twoByteBuffer, sizeof(twoByteBuffer));
+
+ // and zero additional records
+ iUdp.write((uint8_t*) &twoByteBuffer, sizeof(twoByteBuffer));
+
+ // Build question
+ const char* start = aName;
+ const char* end = start;
+ uint8_t len;
+ // Run through the name being requested
+
+ while(*end) {
+
+ // Find out how long this section of the name is
+ end = start;
+ while(*end && (*end != '.')) {
+ end++;
+ }
+
+ if(end - start > 0) {
+
+ // Write out the size of this section
+ len = end - start;
+ iUdp.write(&len, sizeof(len));
+
+ // And then write out the section
+ iUdp.write((uint8_t*)start, end - start);
+ }
+
+ start = end + 1;
+ }
+
+ // We've got to the end of the question name, so
+ // terminate it with a zero-length section
+ len = 0;
+ iUdp.write(&len, sizeof(len));
+
+ // Finally the type and class of question
+ twoByteBuffer = htons(TYPE_A);
+ iUdp.write((uint8_t*) &twoByteBuffer, sizeof(twoByteBuffer));
+
+ twoByteBuffer = htons(CLASS_IN); // Internet class of question
+ iUdp.write((uint8_t*) &twoByteBuffer, sizeof(twoByteBuffer));
+
+ // Success! Everything buffered okay
+ return 1;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+uint16_t DNSClient::ProcessResponse(uint16_t aTimeout, IPAddress& aAddress) {
+ uint32_t startTime = clock_time();
+
+ // Wait for a response packet
+
+ while(iUdp.parsePacket() <= 0) {
+ if((clock_time() - startTime) > aTimeout)
+ return TIMED_OUT;
+ wait(0.050);
+ }
+
+ // We've had a reply!
+ // Read the UDP header
+ uint8_t header[DNS_HEADER_SIZE]; // Enough space to reuse for the DNS header
+
+ // Check that it's a response from the right server and the right port
+ if((iDNSServer != iUdp.remoteIP()) || (iUdp.remotePort() != DNS_PORT)) {
+
+ // It's not from who we expected
+ return INVALID_SERVER;
+ }
+
+ // Read through the rest of the response
+ if(iUdp.available() < DNS_HEADER_SIZE) {
+ return TRUNCATED;
+ }
+
+ iUdp.read(header, DNS_HEADER_SIZE);
+
+ uint16_t header_flags = htons(*((uint16_t*) &header[2]));
+ // Check that it's a response to this request
+
+ if
+ (
+ (iRequestId != (*((uint16_t*) &header[0])))
+ || ((header_flags & QUERY_RESPONSE_MASK) != (uint16_t) RESPONSE_FLAG)
+ ) {
+
+ // Mark the entire packet as read
+ iUdp.flush();
+ return INVALID_RESPONSE;
+ }
+
+ // Check for any errors in the response (or in our request)
+ // although we don't do anything to get round these
+ if((header_flags & TRUNCATION_FLAG) || (header_flags & RESP_MASK)) {
+
+ // Mark the entire packet as read
+ iUdp.flush();
+ return -5; //INVALID_RESPONSE;
+ }
+
+ // And make sure we've got (at least) one answer
+ uint16_t answerCount = htons(*((uint16_t*) &header[6]));
+ if(answerCount == 0) {
+
+ // Mark the entire packet as read
+ iUdp.flush();
+ return -6; //INVALID_RESPONSE;
+ }
+
+ // Skip over any questions
+ for(uint16_t i = 0; i < htons(*((uint16_t*) &header[4])); i++) {
+
+ // Skip over the name
+ uint8_t len;
+ do
+ {
+ iUdp.read(&len, sizeof(len));
+ if(len > 0) {
+
+ // Don't need to actually read the data out for the string, just
+ // advance ptr to beyond it
+ while(len--) {
+ iUdp.read(); // we don't care about the returned byte
+ }
+ }
+ } while(len != 0);
+
+ // Now jump over the type and class
+ for(int i = 0; i < 4; i++) {
+ iUdp.read(); // we don't care about the returned byte
+ }
+ }
+
+ // Now we're up to the bit we're interested in, the answer
+ // There might be more than one answer (although we'll just use the first
+ // type A answer) and some authority and additional resource records but
+ // we're going to ignore all of them.
+ for(uint16_t i = 0; i < answerCount; i++) {
+
+ // Skip the name
+ uint8_t len;
+ do
+ {
+ iUdp.read(&len, sizeof(len));
+ if((len & LABEL_COMPRESSION_MASK) == 0) {
+
+ // It's just a normal label
+ if(len > 0) {
+
+ // And it's got a length
+ // Don't need to actually read the data out for the string,
+ // just advance ptr to beyond it
+ while(len--) {
+ iUdp.read(); // we don't care about the returned byte
+ }
+ }
+ }
+ else {
+
+ // This is a pointer to a somewhere else in the message for the
+ // rest of the name. We don't care about the name, and RFC1035
+ // says that a name is either a sequence of labels ended with a
+ // 0 length octet or a pointer or a sequence of labels ending in
+ // a pointer. Either way, when we get here we're at the end of
+ // the name
+ // Skip over the pointer
+ iUdp.read(); // we don't care about the returned byte
+
+ // And set len so that we drop out of the name loop
+ len = 0;
+ }
+ } while(len != 0);
+
+ // Check the type and class
+ uint16_t answerType;
+ uint16_t answerClass;
+ iUdp.read((uint8_t*) &answerType, sizeof(answerType));
+ iUdp.read((uint8_t*) &answerClass, sizeof(answerClass));
+
+ // Ignore the Time-To-Live as we don't do any caching
+ for(int i = 0; i < TTL_SIZE; i++) {
+ iUdp.read(); // we don't care about the returned byte
+ }
+
+ // And read out the length of this answer
+ // Don't need header_flags anymore, so we can reuse it here
+ iUdp.read((uint8_t*) &header_flags, sizeof(header_flags));
+
+ if((htons(answerType) == TYPE_A) && (htons(answerClass) == CLASS_IN)) {
+ if(htons(header_flags) != 4) {
+
+ // It's a weird size
+ // Mark the entire packet as read
+ iUdp.flush();
+ return -9; //INVALID_RESPONSE;
+ }
+
+ iUdp.read(aAddress.raw_address(), 4);
+ return SUCCESS;
+ }
+ else {
+
+ // This isn't an answer type we're after, move onto the next one
+ for(uint16_t i = 0; i < htons(header_flags); i++) {
+ iUdp.read(); // we don't care about the returned byte
+ }
+ }
+ }
+
+ // Mark the entire packet as read
+ iUdp.flush();
+
+ // If we get here then we haven't found an answer
+ return -10; //INVALID_RESPONSE;
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Dns.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,39 @@
+// mbed DNS client for Enc28J60-based Ethernet shield
+// (c) Copyright 2009-2010 MCQN Ltd.
+// Released under Apache License, version 2.0
+#ifndef DNSClient_h
+ #define DNSClient_h
+
+ #include <UIPUdp.h>
+
+class DNSClient
+{
+public:
+ // ctor
+ void begin(const IPAddress& aDNSServer);
+
+ /** Convert a numeric IP address string into a four-byte IP address.
+ @param aIPAddrString IP address to convert
+ @param aResult IPAddress structure to store the returned IP address
+ @result 1 if aIPAddrString was successfully converted to an IP address,
+ else error code
+ */
+ int inet_aton(const char* aIPAddrString, IPAddress& aResult);
+
+ /** Resolve the given hostname to an IP address.
+ @param aHostname Name to be resolved
+ @param aResult IPAddress structure to store the returned IP address
+ @result 1 if aIPAddrString was successfully converted to an IP address,
+ else error code
+ */
+ int getHostByName(const char* aHostname, IPAddress& aResult);
+protected:
+ uint16_t BuildRequest(const char* aName);
+ uint16_t ProcessResponse(uint16_t aTimeout, IPAddress& aAddress);
+
+ IPAddress iDNSServer;
+ uint16_t iRequestId;
+ UIPUDP iUdp;
+};
+#endif
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Readme.txt Mon Sep 15 11:12:30 2014 +0000 @@ -0,0 +1,245 @@ +This is UIPEthernet version 1.07 + +Ethernet library for ENC28J60 shields and breakout boards. Full support for persistent (streaming) TCP-connections and UDP (Client and Server each), ARP, ICMP, DHCP and DNS. +Just include 'UIPEthernet.h' and create one IUPEthernet object initialized with the SPI pins of your ENC28J60 board. + +UIPEthernet is written as a wrapper around the mature uIP Stack by Adam Dunkels, which provides the low-level implementation for all supported protocols. To overcome the memory-constrains (a 'regular' uIP-application does all processing in RAM) the ENC28J60 internal memory is used for all stream buffers (in and out). Only 400-600 Bytes of Arduinos RAM are used (depending on the number of concurrently open connections). As of Flash-memory a ATmega368-based Arduino is the minimum requirenment. + +This library is written by Norbert Truchsess <norbert.truchsess@t-online.de> + +uIP was written by Adam Dunkels of the Networked Embedded Systems group at the Swedish Institute of Computer Science. + +This library was inspired by the SerialIP implementation by Adam Nielsen <malvineous@shikadi.net>, actually I took this code as a starting point, but in the latest versions there are very few lines left. + +Installation +------------ + +Import into your project as any other mbed library. + +Additional information can be found on the mbed website: https://mbed.org/handbook/mbed-Compiler + +Documentation +------------- + +For more information visit: + + - UIPEthernet Repository on github: + https://github.com/ntruchsess/arduino_uip + + - Arduino Ethernet library description + http://arduino.cc/en/Reference/Ethernet + (Arduino_uip uses the same API as that, just include "UIPEthernet.h", "UIPClient.h", "UIPServer.h" and "UIPUDP.h" instead of the stock "Ethernet.h", "EthernetClient.h", "EthernetServer.h " and "EthernetUDP.h") + + - uIP API reference: + http://www.sics.se/~adam/uip/uip-1.0-refman/ + + - uIP homepage: + http://www.sics.se/~adam/uip/index.php/Main_Page + +Licenses +------------- + +UIPEthernet.h +UIPEthernet.cpp + +Copyright (c) 2013 Norbert Truchsess <norbert.truchsess@t-online.de> +All rights reserved. + +Modified (ported to mbed) by Zoltan Hudak <hudakz@inbox.com> + +UIPServer.h +UIPServer.cpp +UIPClient.h +UIPClient.cpp +UIPUdp.h +UIPUdp.cpp +utility/mempool.h +utility/mempool.cpp + +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/>. + +-------------- + +utility/enc28j60.h + +Author : Pascal Stang (c)2005 +Modified by Norbert Truchsess +Copyright: GPL V2 + +-------------- + +utility/Enc28J60Network.h +utility/Enc28J60Network.cpp + +Copyright (c) 2013 Norbert Truchsess <norbert.truchsess@t-online.de> +All rights reserved. + +inspired and based on enc28j60.c file from the AVRlib library by Pascal Stang. + +Modified (ported to mbed) by Zoltan Hudak <hudakz@inbox.com> + +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/>. + +-------------- + +utility/uip.c +utility/uip_arp.h +utility/uip_arp.c +utility/uip_arch.h +utility/uip.h +utility/uipopt.h + +Copyright (c) 2001-2003, Adam Dunkels <adam@sics.se>, <adam@dunkels.com>. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of the Institute nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +SUCH DAMAGE. + +-------------- + +uip-conf.h +utility/uip-neighbor.h +utility/uip-neighbor.c +utility/uip_timer.h +utility/uip_timer.c +utility/uip_clock.h + +Author Adam Dunkels Adam Dunkels <adam@sics.se>, <adam@dunkels.com> +Copyright (c) 2004,2006, Swedish Institute of Computer Science. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of the Institute nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +SUCH DAMAGE. + +-------------- + +Dhcp.h +Dhcp.cpp + +DHCP Library v0.3 - April 25, 2009 +Author: Jordan Terrell - blog.jordanterrell.com +- as included in Arduinos stock Ethernet-library, no special licence mentioned here + +-------------- + +Dns.h +Dns.cpp + +(c) Copyright 2009-2010 MCQN Ltd. +Released under Apache License, version 2.0 + +-------------- + +clock-arch.h +clock-arch.c + +Copyright (c) 2010 Adam Nielsen <malvineous@shikadi.net> +All rights reserved. + +Modified (ported to mbed) by Zoltan Hudak <hudakz@inbox.com> + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library 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 +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +-------------- + +Client.h +IPAddress.h +IPAddress.cpp +Server.h +Copyright (c) 2011 Adrian McEwen. All right reserved. + +Modified (ported to mbed) by Zoltan Hudak <hudakz@inbox.com> + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library 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 +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +
--- /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;
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/UIPClient.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,98 @@
+/*
+ UIPClient.h - 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/>.
+ */
+#ifndef UIPCLIENT_H
+ #define UIPCLIENT_H
+
+ #include "ethernet_comp.h"
+ #include "Client.h"
+ #include "mempool.h"
+
+extern "C"
+{
+ #include "uip.h"
+}
+ #define UIP_SOCKET_DATALEN UIP_TCP_MSS
+//#define UIP_SOCKET_NUMPACKETS UIP_RECEIVE_WINDOW/UIP_TCP_MSS+1
+
+ #ifndef UIP_SOCKET_NUMPACKETS
+ #define UIP_SOCKET_NUMPACKETS 5
+ #endif
+ #define UIP_CLIENT_CLOSE 1
+ #define UIP_CLIENT_CLOSED 2
+ #define UIP_CLIENT_RESTART 4
+
+typedef uint8_t uip_socket_ptr;
+
+typedef struct
+{
+ uint8_t state;
+ memhandle packets_in[UIP_SOCKET_NUMPACKETS];
+ uint16_t lport; /**< The local TCP port, in network byte order. */
+} uip_userdata_closed_t;
+
+typedef struct
+{
+ uint8_t state;
+ memhandle packets_in[UIP_SOCKET_NUMPACKETS];
+ memhandle packets_out[UIP_SOCKET_NUMPACKETS];
+ memaddress out_pos;
+} uip_userdata_t;
+
+class UIPClient :
+ public Client
+{
+public:
+ UIPClient(void);
+ int connect(IPAddress ip, uint16_t port);
+ int connect(const char* host, uint16_t port);
+ int read(uint8_t* buf, size_t size);
+ void stop(void);
+ uint8_t connected(void);
+ operator bool(void);
+ virtual bool operator ==(const EthernetClient& );
+ virtual bool operator !=(const EthernetClient& rhs) { return !this->operator ==(rhs); };
+
+ size_t write(uint8_t);
+ size_t write(const uint8_t* buf, size_t size);
+ int available(void);
+ int read(void);
+ int peek(void);
+ void flush(void);
+private:
+ UIPClient(struct uip_conn* _conn);
+ UIPClient(uip_userdata_closed_t* closed_conn);
+
+ struct uip_conn* _uip_conn;
+
+ uip_userdata_t* data;
+
+ static uip_userdata_closed_t* closed_conns[UIP_CONNS];
+
+ static size_t _write(struct uip_conn* , const uint8_t* buf, size_t size);
+ static int _available(uip_userdata_t* );
+
+ static memhandle* _currentBlock(memhandle* blocks);
+ static void _eatBlock(memhandle* blocks);
+ static void _flushBlocks(memhandle* blocks);
+
+ friend class UIPEthernetClass;
+ friend class UIPServer;
+ static void uip_callback(uip_tcp_appstate_t* s);
+};
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/UIPEthernet.cpp Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,591 @@
+/*
+ UIPEthernet.cpp - Arduino implementation of a uIP wrapper class.
+ Copyright (c) 2013 Norbert Truchsess <norbert.truchsess@t-online.de>
+ All rights reserved.
+
+ Modified (ported to mbed) by Zoltan Hudak <hudakz@inbox.com>
+
+ 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/>.
+ */
+#pragma once
+#include <mbed.h>
+#include "UIPEthernet.h"
+#include "Enc28J60Network.h"
+
+#if (defined UIPETHERNET_DEBUG || defined UIPETHERNET_DEBUG_CHKSUM)
+ #include "HardwareSerial.h"
+#endif
+extern "C"
+{
+#include "uip-conf.h"
+#include "uip.h"
+#include "uip_arp.h"
+#include "uip_timer.h"
+}
+#define ETH_HDR ((struct uip_eth_hdr*) &uip_buf[0])
+
+// Because uIP isn't encapsulated within a class we have to use global
+
+// variables, so we can only have one TCP/IP stack per program.
+UIPEthernetClass::UIPEthernetClass(PinName mosi, PinName miso, PinName sck, PinName cs) :
+ network(mosi, miso, sck, cs),
+ fn_uip_cb(NULL),
+ fn_uip_udp_cb(NULL),
+ in_packet(NOBLOCK),
+ uip_packet(NOBLOCK),
+ uip_hdrlen(0),
+ packetstate(0),
+ _dhcp(NULL)
+{ }
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+int UIPEthernetClass::begin(const uint8_t* mac) {
+ static DhcpClass s_dhcp;
+ _dhcp = &s_dhcp;
+
+ // Initialise the basic info
+ init(mac);
+
+ // Now try to get our config info from a DHCP server
+ int ret = _dhcp->beginWithDHCP((uint8_t*)mac);
+ if(ret == 1) {
+
+ // We've successfully found a DHCP server and got our configuration info, so set things
+ // accordingly
+ configure(_dhcp->getLocalIp(), _dhcp->getDnsServerIp(), _dhcp->getGatewayIp(), _dhcp->getSubnetMask());
+ }
+
+ return ret;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPEthernetClass::begin(const uint8_t* mac, IPAddress ip) {
+ IPAddress dns = ip;
+ dns[3] = 1;
+ begin(mac, ip, dns);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPEthernetClass::begin(const uint8_t* mac, IPAddress ip, IPAddress dns) {
+ IPAddress gateway = ip;
+ gateway[3] = 1;
+ begin(mac, ip, dns, gateway);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPEthernetClass::begin(const uint8_t* mac, IPAddress ip, IPAddress dns, IPAddress gateway) {
+ IPAddress subnet(255, 255, 255, 0);
+ begin(mac, ip, dns, gateway, subnet);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPEthernetClass::begin(const uint8_t* mac, IPAddress ip, IPAddress dns, IPAddress gateway, IPAddress subnet) {
+ init(mac);
+ configure(ip, dns, gateway, subnet);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+int UIPEthernetClass::maintain(void) {
+ tick();
+
+ int rc = DHCP_CHECK_NONE;
+ if(_dhcp != NULL) {
+
+ //we have a pointer to dhcp, use it
+ rc = _dhcp->checkLease();
+ switch(rc) {
+ case DHCP_CHECK_NONE:
+ //nothing done
+ break;
+
+ case DHCP_CHECK_RENEW_OK:
+ case DHCP_CHECK_REBIND_OK:
+ //we might have got a new IP.
+ configure(_dhcp->getLocalIp(), _dhcp->getDnsServerIp(), _dhcp->getGatewayIp(), _dhcp->getSubnetMask());
+ break;
+
+ default:
+ //this is actually a error, it will retry though
+ break;
+ }
+ }
+
+ return rc;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+IPAddress UIPEthernetClass::localIP(void) {
+ IPAddress ret;
+ uip_ipaddr_t a;
+ uip_gethostaddr(a);
+ return ip_addr_uip(a);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+IPAddress UIPEthernetClass::subnetMask(void) {
+ IPAddress ret;
+ uip_ipaddr_t a;
+ uip_getnetmask(a);
+ return ip_addr_uip(a);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+IPAddress UIPEthernetClass::gatewayIP(void) {
+ IPAddress ret;
+ uip_ipaddr_t a;
+ uip_getdraddr(a);
+ return ip_addr_uip(a);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+IPAddress UIPEthernetClass::dnsServerIP(void) {
+ return _dnsServerAddress;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPEthernetClass::tick(void) {
+ if(in_packet == NOBLOCK) {
+ in_packet = network.receivePacket();
+#ifdef UIPETHERNET_DEBUG
+ if(in_packet != NOBLOCK) {
+ Serial.print("--------------\nreceivePacket: ");
+ Serial.println(in_packet);
+ }
+#endif
+ }
+
+ if(in_packet != NOBLOCK) {
+ packetstate = UIPETHERNET_FREEPACKET;
+ uip_len = network.blockSize(in_packet);
+ if(uip_len > 0) {
+ network.readPacket(in_packet, 0, (uint8_t*)uip_buf, UIP_BUFSIZE);
+ if(ETH_HDR->type == HTONS(UIP_ETHTYPE_IP)) {
+ uip_packet = in_packet;
+#ifdef UIPETHERNET_DEBUG
+ Serial.print("readPacket type IP, uip_len: ");
+ Serial.println(uip_len);
+#endif
+ uip_arp_ipin();
+ uip_input();
+ if(uip_len > 0) {
+ uip_arp_out();
+ network_send();
+ }
+ }
+ else
+ if(ETH_HDR->type == HTONS(UIP_ETHTYPE_ARP))
+ {
+#ifdef UIPETHERNET_DEBUG
+ Serial.print("readPacket type ARP, uip_len: ");
+ Serial.println(uip_len);
+#endif
+ uip_arp_arpin();
+ if(uip_len > 0) {
+ network_send();
+ }
+ }
+ }
+
+ if(in_packet != NOBLOCK && (packetstate & UIPETHERNET_FREEPACKET))
+ {
+#ifdef UIPETHERNET_DEBUG
+ Serial.print("freeing packet: ");
+ Serial.println(in_packet);
+#endif
+ network.freePacket();
+ in_packet = NOBLOCK;
+ }
+ }
+
+ if(uip_timer_expired(&periodic_timer)) {
+ uip_timer_restart(&periodic_timer);
+ for(int i = 0; i < UIP_CONNS; i++) {
+ uip_periodic(i);
+
+ // If the above function invocation resulted in data that
+ // should be sent out on the network, the global variable
+ // uip_len is set to a value > 0.
+ if(uip_len > 0) {
+ uip_arp_out();
+ network_send();
+ }
+ }
+
+#if UIP_UDP
+ for(int i = 0; i < UIP_UDP_CONNS; i++) {
+ uip_udp_periodic(i);
+
+ // If the above function invocation resulted in data that
+ // should be sent out on the network, the global variable
+ // uip_len is set to a value > 0. */
+ if(uip_len > 0) {
+ network_send();
+ }
+ }
+#endif /* UIP_UDP */
+ }
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+bool UIPEthernetClass::network_send(void) {
+ if(packetstate & UIPETHERNET_SENDPACKET)
+ {
+#ifdef UIPETHERNET_DEBUG
+ Serial.print("network_send uip_packet: ");
+ Serial.print(uip_packet);
+ Serial.print(", hdrlen: ");
+ Serial.println(uip_hdrlen);
+#endif
+ network.writePacket(uip_packet, 0, uip_buf, uip_hdrlen);
+ goto sendandfree;
+ }
+
+ uip_packet = network.allocBlock(uip_len);
+ if(uip_packet != NOBLOCK)
+ {
+#ifdef UIPETHERNET_DEBUG
+ Serial.print("network_send uip_buf (uip_len): ");
+ Serial.print(uip_len);
+ Serial.print(", packet: ");
+ Serial.println(uip_packet);
+#endif
+ network.writePacket(uip_packet, 0, uip_buf, uip_len);
+ goto sendandfree;
+ }
+
+ return false;
+sendandfree:
+ network.sendPacket(uip_packet);
+ network.freeBlock(uip_packet);
+ uip_packet = NOBLOCK;
+ return true;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPEthernetClass::init(const uint8_t* mac) {
+ uip_timer_set(&this->periodic_timer, CLOCK_SECOND / 4);
+
+ network.init((uint8_t*)mac);
+ uip_seteth_addr(mac);
+
+ uip_init();
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPEthernetClass::configure(IPAddress ip, IPAddress dns, IPAddress gateway, IPAddress subnet) {
+ uip_ipaddr_t ipaddr;
+
+ uip_ip_addr(ipaddr, ip);
+ uip_sethostaddr(ipaddr);
+
+ uip_ip_addr(ipaddr, gateway);
+ uip_setdraddr(ipaddr);
+
+ uip_ip_addr(ipaddr, subnet);
+ uip_setnetmask(ipaddr);
+
+ _dnsServerAddress = dns;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPEthernetClass::set_uip_callback(fn_uip_cb_t fn) {
+ this->fn_uip_cb = fn;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPEthernetClass::uip_callback(void) {
+ struct uipethernet_state* s = &(uip_conn->appstate);
+
+ if(this->fn_uip_cb) {
+
+ // The sketch wants to handle all uIP events itself, using uIP functions.
+ this->fn_uip_cb(s); //->p, &s->user);
+ }
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPEthernetClass::set_uip_udp_callback(fn_uip_udp_cb_t fn) {
+ this->fn_uip_udp_cb = fn;
+}
+
+#if UIP_UDP
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPEthernetClass::uip_udp_callback(void) {
+ struct uipudp_state* s = &(uip_udp_conn->appstate);
+
+ if(this->fn_uip_udp_cb) {
+
+ // The sketch wants to handle all uIP events itself, using uIP functions.
+ this->fn_uip_udp_cb(s); //->p, &s->user);
+ }
+}
+#endif
+//UIPEthernetClass UIPEthernet;
+
+// uIP callback function
+void uipethernet_appcall(void) {
+ UIPEthernet.uip_callback();
+}
+
+#if UIP_UDP
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void uipudp_appcall(void) {
+ UIPEthernet.uip_udp_callback();
+}
+#endif
+
+/*---------------------------------------------------------------------------*/
+uint16_t UIPEthernetClass::chksum(uint16_t sum, const uint8_t* data, uint16_t len) {
+ uint16_t t;
+ const uint8_t* dataptr;
+ const uint8_t* last_byte;
+
+ dataptr = data;
+ last_byte = data + len - 1;
+
+ while(dataptr < last_byte) {
+
+ /* At least two more bytes */
+ t = (dataptr[0] << 8) + dataptr[1];
+ sum += t;
+ if(sum < t) {
+ sum++; /* carry */
+ }
+
+ dataptr += 2;
+ }
+
+ if(dataptr == last_byte) {
+ t = (dataptr[0] << 8) + 0;
+ sum += t;
+ if(sum < t) {
+ sum++; /* carry */
+ }
+ }
+
+ /* Return sum in host byte order. */
+ return sum;
+}
+
+/*---------------------------------------------------------------------------*/
+uint16_t UIPEthernetClass::ipchksum(void) {
+ uint16_t sum;
+
+ sum = chksum(0, &uip_buf[UIP_LLH_LEN], UIP_IPH_LEN);
+ return(sum == 0) ? 0xffff : htons(sum);
+}
+
+/*---------------------------------------------------------------------------*/
+uint16_t UIPEthernetClass::upper_layer_chksum(uint8_t proto) {
+ uint16_t upper_layer_len;
+ uint16_t sum;
+
+#if UIP_CONF_IPV6
+ upper_layer_len = (((u16_t) (BUF->len[0]) << 8) + BUF->len[1]);
+#else /* UIP_CONF_IPV6 */
+ upper_layer_len = (((u16_t) (BUF->len[0]) << 8) + BUF->len[1]) - UIP_IPH_LEN;
+#endif /* UIP_CONF_IPV6 */
+
+ /* First sum pseudoheader. */
+
+ /* IP protocol and length fields. This addition cannot carry. */
+ sum = upper_layer_len + proto;
+
+ /* Sum IP source and destination addresses. */
+ sum = chksum(sum, (u8_t*) &BUF->srcipaddr[0], 2 * sizeof(uip_ipaddr_t));
+
+ uint8_t upper_layer_memlen;
+ switch(proto) {
+ case UIP_PROTO_ICMP:
+ case UIP_PROTO_ICMP6:
+ upper_layer_memlen = upper_layer_len;
+ break;
+
+ case UIP_PROTO_TCP:
+ upper_layer_memlen = (BUF->tcpoffset >> 4) << 2;
+ break;
+#if UIP_UDP
+
+ case UIP_PROTO_UDP:
+ upper_layer_memlen = UIP_UDPH_LEN;
+ break;
+#endif
+ }
+
+ sum = chksum(sum, &uip_buf[UIP_IPH_LEN + UIP_LLH_LEN], upper_layer_memlen);
+#ifdef UIPETHERNET_DEBUG_CHKSUM
+ Serial.print("chksum uip_buf[");
+ Serial.print(UIP_IPH_LEN + UIP_LLH_LEN);
+ Serial.print("-");
+ Serial.print(UIP_IPH_LEN + UIP_LLH_LEN + upper_layer_memlen);
+ Serial.print("]: ");
+ Serial.println(htons(sum), HEX);
+#endif
+ if(upper_layer_memlen < upper_layer_len) {
+ sum = network.chksum
+ (
+ sum,
+ uip_packet,
+ UIP_IPH_LEN + UIP_LLH_LEN + upper_layer_memlen,
+ upper_layer_len - upper_layer_memlen
+ );
+#ifdef UIPETHERNET_DEBUG_CHKSUM
+ Serial.print("chksum uip_packet(");
+ Serial.print(uip_packet);
+ Serial.print(")[");
+ Serial.print(UIP_IPH_LEN + UIP_LLH_LEN + upper_layer_memlen);
+ Serial.print("-");
+ Serial.print(UIP_IPH_LEN + UIP_LLH_LEN + upper_layer_len);
+ Serial.print("]: ");
+ Serial.println(htons(sum), HEX);
+#endif
+ }
+
+ return(sum == 0) ? 0xffff : htons(sum);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+uint16_t uip_ipchksum(void) {
+ return UIPEthernet.ipchksum();
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+uint16_t uip_tcpchksum(void) {
+ uint16_t sum = UIPEthernet.upper_layer_chksum(UIP_PROTO_TCP);
+ return sum;
+}
+
+#if UIP_UDP
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+uint16_t uip_udpchksum(void) {
+ uint16_t sum = UIPEthernet.upper_layer_chksum(UIP_PROTO_UDP);
+ return sum;
+}
+#endif
+
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/UIPEthernet.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,140 @@
+/*
+ UIPEthernet.h - Arduino implementation of a uIP wrapper class.
+ Copyright (c) 2013 Norbert Truchsess <norbert.truchsess@t-online.de>
+ All rights reserved.
+
+ Modified (ported to mbed) by Zoltan Hudak <hudakz@inbox.com>
+
+ 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/>.
+ */
+#pragma once
+#ifndef UIPETHERNET_H
+ #define UIPETHERNET_H
+
+ #include "ethernet_comp.h"
+ #include <mbed.h>
+ #include "Dhcp.h"
+ #include "IPAddress.h"
+ #include "Enc28J60Network.h"
+ #include "UIPClient.h"
+ #include "UIPServer.h"
+ #include "UIPUdp.h"
+
+extern "C"
+{
+ #include "uip_timer.h"
+ #include "uip.h"
+}
+//#define UIPETHERNET_DEBUG
+//#define UIPETHERNET_DEBUG_CHKSUM
+//#define UIPETHERNET_DEBUG_UDP
+//#define UIPETHERNET_DEBUG_CLIENT
+ #define UIPETHERNET_FREEPACKET 1
+ #define UIPETHERNET_SENDPACKET 2
+ #define UIPETHERNET_BUFFERREAD 4
+
+ #define uip_ip_addr(addr, ip) \
+ do \
+ { \
+ ((u16_t *) (addr))[0] = HTONS(((ip[0]) << 8) | (ip[1])); \
+ ((u16_t *) (addr))[1] = HTONS(((ip[2]) << 8) | (ip[3])); \
+ } while(0)
+ #define ip_addr_uip(a) IPAddress(a[0] & 0xFF, a[0] >> 8, a[1] & 0xFF, a[1] >> 8); //TODO this is not IPV6 capable
+
+ #define uip_seteth_addr(eaddr) \
+ do \
+ { \
+ uip_ethaddr.addr[0] = eaddr[0]; \
+ uip_ethaddr.addr[1] = eaddr[1]; \
+ uip_ethaddr.addr[2] = eaddr[2]; \
+ uip_ethaddr.addr[3] = eaddr[3]; \
+ uip_ethaddr.addr[4] = eaddr[4]; \
+ uip_ethaddr.addr[5] = eaddr[5]; \
+ } while(0)
+
+ typedef void (*fn_uip_cb_t) (uip_tcp_appstate_t * conn);
+
+typedef void (*fn_uip_udp_cb_t) (uip_udp_appstate_t * conn);
+
+ #define BUF ((struct uip_tcpip_hdr*) &uip_buf[UIP_LLH_LEN])
+
+class UIPEthernetClass
+{
+public:
+ UIPEthernetClass(PinName mosi, PinName miso, PinName sck, PinName cs);
+
+ int begin(const uint8_t* mac);
+ void begin(const uint8_t* mac, IPAddress ip);
+ void begin(const uint8_t* mac, IPAddress ip, IPAddress dns);
+ void begin(const uint8_t* mac, IPAddress ip, IPAddress dns, IPAddress gateway);
+ void begin(const uint8_t* mac, IPAddress ip, IPAddress dns, IPAddress gateway, IPAddress subnet);
+
+ // maintain() must be called at regular intervals to process the incoming serial
+ // data and issue IP events to the sketch. It does not return until all IP
+ // events have been processed. Renews dhcp-lease if required.
+ int maintain(void);
+
+ IPAddress localIP(void);
+ IPAddress subnetMask(void);
+ IPAddress gatewayIP(void);
+ IPAddress dnsServerIP(void);
+
+ // Set a user function to handle raw uIP events as they happen. The
+ // callback function can only use uIP functions, but it can also use uIP's
+ // protosockets.
+ void set_uip_callback(fn_uip_cb_t fn);
+ void set_uip_udp_callback(fn_uip_udp_cb_t fn);
+private:
+ IPAddress _dnsServerAddress;
+ DhcpClass* _dhcp;
+
+ struct uip_timer periodic_timer;
+ fn_uip_cb_t fn_uip_cb;
+ fn_uip_udp_cb_t fn_uip_udp_cb;
+
+ memhandle in_packet;
+ memhandle uip_packet;
+ uint8_t uip_hdrlen;
+ uint8_t packetstate;
+
+ Enc28J60Network network;
+
+ void init(const uint8_t* mac);
+ void configure(IPAddress ip, IPAddress dns, IPAddress gateway, IPAddress subnet);
+ void tick(void);
+ bool network_send(void);
+ void uip_callback(void);
+ friend void uipethernet_appcall(void);
+ void uip_udp_callback(void);
+ friend void uipudp_appcall(void);
+ friend class UIPServer;
+ friend class UIPClient;
+ friend class UIPUDP;
+
+ static uint16_t chksum(uint16_t sum, const uint8_t* data, uint16_t len);
+ static uint16_t ipchksum(void);
+ uint16_t upper_layer_chksum(uint8_t proto);
+
+ friend uint16_t uip_ipchksum(void);
+ friend uint16_t uip_tcpchksum(void);
+ friend uint16_t uip_udpchksum(void);
+
+ #if UIP_CONF_IPV6
+ uint16_t uip_icmp6chksum(void);
+ #endif /* UIP_CONF_IPV6 */
+};
+
+extern UIPEthernetClass UIPEthernet;
+#endif
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/UIPServer.cpp Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,109 @@
+/*
+ UIPServer.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/>.
+ */
+#include "UIPEthernet.h"
+#include "UIPServer.h"
+extern "C"
+{
+#include "uip-conf.h"
+}
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+UIPServer::UIPServer(uint16_t port) :
+ _port(htons(port)) {
+ UIPEthernet.set_uip_callback(&UIPClient::uip_callback);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+UIPClient UIPServer::available(void) {
+ UIPEthernet.tick();
+
+ uip_userdata_t* u;
+ for(uint8_t sock = 0; sock < UIP_CONNS; sock++) {
+ struct uip_conn* conn = &uip_conns[sock];
+ if(conn->lport == _port && (u = (uip_userdata_t*)conn->appstate.user)) {
+ if(UIPClient::_available(u))
+ return UIPClient(conn);
+ }
+ }
+
+ uip_userdata_closed_t ** cc = &UIPClient::closed_conns[0];
+ for(uint8_t i = 0; i < UIP_CONNS; i++) {
+ if(*cc && (*cc)->lport == _port) {
+ if((*cc)->packets_in[0] == NOBLOCK) {
+ free(*cc);
+ *cc = NULL;
+ }
+ else
+ return UIPClient(*cc);
+ }
+
+ cc++;
+ }
+
+ return UIPClient();
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPServer::begin(void) {
+ uip_listen(_port);
+ UIPEthernet.tick();
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+size_t UIPServer::write(uint8_t c) {
+ return write(&c, 1);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+size_t UIPServer::write(const uint8_t* buf, size_t size) {
+ size_t ret = 0;
+ for(int sock = 0; sock < UIP_CONNS; sock++) {
+ struct uip_conn* conn = &uip_conns[sock];
+ if(conn->lport == _port && (conn->tcpstateflags != UIP_CLOSE))
+ ret = UIPClient::_write(conn, buf, size);
+ }
+
+ return ret;
+}
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/UIPServer.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,43 @@
+/*
+ UIPServer.h - 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/>.
+ */
+#ifndef UIPSERVER_H
+ #define UIPSERVER_H
+
+ #include "ethernet_comp.h"
+ #include "Server.h"
+ #include "UIPClient.h"
+
+class UIPServer :
+ Server
+{
+public:
+ UIPServer(uint16_t);
+ UIPClient available(void);
+ void begin(void);
+ size_t write(uint8_t);
+ size_t write(const uint8_t* buf, size_t size);
+
+// using Print::write;
+
+private:
+ uint16_t _port;
+};
+#endif
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/UIPUdp.cpp Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,406 @@
+/*
+ UIPUdp.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/>.
+ */
+#include "UIPEthernet.h"
+#include "UIPUdp.h"
+#include "Dns.h"
+
+#ifdef UIPETHERNET_DEBUG_UDP
+ #include "mbed.h"
+#endif
+extern "C"
+{
+#include "uip-conf.h"
+#include "uip.h"
+#include "uip_arp.h"
+}
+#if UIP_UDP
+ #define UIP_ARPHDRSIZE 42
+ #define UDPBUF ((struct uip_udpip_hdr*) &uip_buf[UIP_LLH_LEN])
+
+// Constructor
+UIPUDP::UIPUDP(void) {
+ _uip_udp_conn = NULL;
+ memset(&appdata, 0, sizeof(appdata));
+ UIPEthernet.set_uip_udp_callback(&UIPUDP::uip_callback);
+}
+
+// initialize, start listening on specified port. Returns 1 if successful, 0 if there are no sockets available to use
+uint8_t UIPUDP::begin(uint16_t port) {
+ if(!_uip_udp_conn) {
+ _uip_udp_conn = uip_udp_new(NULL, 0);
+ }
+
+ if(_uip_udp_conn) {
+ uip_udp_bind(_uip_udp_conn, htons(port));
+ _uip_udp_conn->appstate.user = &appdata;
+ return 1;
+ }
+
+ return 0;
+}
+
+// Finish with the UDP socket
+void UIPUDP::stop(void) {
+ if(_uip_udp_conn) {
+ flush();
+ uip_udp_remove(_uip_udp_conn);
+ _uip_udp_conn->appstate.user = NULL;
+ _uip_udp_conn = NULL;
+ if(appdata.packet_in != NOBLOCK) {
+ UIPEthernet.network.freeBlock(appdata.packet_in);
+ appdata.packet_in = NOBLOCK;
+ }
+
+ uint8_t i = 0;
+ memhandle* packet = &appdata.packets_in[0];
+ while(*packet != NOBLOCK && i < UIP_UDP_NUMPACKETS) {
+ UIPEthernet.network.freeBlock(*packet);
+ *packet++ = NOBLOCK;
+ i++;
+ }
+
+ if(appdata.packet_out != NOBLOCK) {
+ UIPEthernet.network.freeBlock(appdata.packet_out);
+ appdata.packet_out = NOBLOCK;
+ }
+ }
+}
+
+// Sending UDP packets
+// Start building up a packet to send to the remote host specific in ip and port
+
+// Returns 1 if successful, 0 if there was a problem with the supplied IP address or port
+int UIPUDP::beginPacket(IPAddress ip, uint16_t port) {
+ UIPEthernet.tick();
+ if(ip && port) {
+ uip_ipaddr_t ripaddr;
+ uip_ip_addr(&ripaddr, ip);
+ #ifdef UIPETHERNET_DEBUG_UDP
+ pc.print("udp beginPacket, ");
+ #endif
+ if(_uip_udp_conn) {
+ _uip_udp_conn->rport = htons(port);
+ uip_ipaddr_copy(_uip_udp_conn->ripaddr, &ripaddr);
+ }
+ else {
+ _uip_udp_conn = uip_udp_new(&ripaddr, htons(port));
+ if(_uip_udp_conn)
+ {
+ #ifdef UIPETHERNET_DEBUG_UDP
+ pc.print("new connection, ");
+ #endif
+ _uip_udp_conn->appstate.user = &appdata;
+ }
+ else
+ {
+ #ifdef UIPETHERNET_DEBUG_UDP
+ pc.println("failed to allocate new connection");
+ #endif
+ return 0;
+ }
+ }
+
+ #ifdef UIPETHERNET_DEBUG_UDP
+ pc.print("rip: ");
+ pc.print(ip);
+ pc.print(", port: ");
+ pc.println(port);
+ #endif
+ }
+
+ if(_uip_udp_conn) {
+ if(appdata.packet_out == NOBLOCK) {
+ appdata.packet_out = UIPEthernet.network.allocBlock(UIP_UDP_MAXPACKETSIZE);
+ appdata.out_pos = UIP_UDP_PHYH_LEN;
+ if(appdata.packet_out != NOBLOCK)
+ return 1;
+ #ifdef UIPETHERNET_DEBUG_UDP
+ else
+ pc.println("failed to allocate memory for packet");
+ #endif
+ }
+
+ #ifdef UIPETHERNET_DEBUG_UDP
+ else
+ pc.println("previous packet on that connection not sent yet");
+ #endif
+ }
+
+ return 0;
+}
+
+// Start building up a packet to send to the remote host specific in host and port
+
+// Returns 1 if successful, 0 if there was a problem resolving the hostname or port
+int UIPUDP::beginPacket(const char* host, uint16_t port) {
+
+ // Look up the host first
+ int ret = 0;
+ DNSClient dns;
+ IPAddress remote_addr;
+
+ dns.begin(UIPEthernet.dnsServerIP());
+ ret = dns.getHostByName(host, remote_addr);
+ if(ret == 1) {
+ return beginPacket(remote_addr, port);
+ }
+ else {
+ return ret;
+ }
+}
+
+// Finish off this packet and send it
+
+// Returns 1 if the packet was sent successfully, 0 if there was an error
+int UIPUDP::endPacket(void) {
+ if(_uip_udp_conn && appdata.packet_out != NOBLOCK) {
+ appdata.send = true;
+ UIPEthernet.network.resizeBlock(appdata.packet_out, 0, appdata.out_pos);
+ uip_udp_periodic_conn(_uip_udp_conn);
+ if(uip_len > 0) {
+ UIPEthernet.network_send();
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+// Write a single byte into the packet
+size_t UIPUDP::write(uint8_t c) {
+ return write(&c, 1);
+}
+
+// Write size bytes from buffer into the packet
+size_t UIPUDP::write(const uint8_t* buffer, size_t size) {
+ if(appdata.packet_out != NOBLOCK) {
+ size_t ret = UIPEthernet.network.writePacket(appdata.packet_out, appdata.out_pos, (uint8_t*)buffer, size);
+ appdata.out_pos += ret;
+ return ret;
+ }
+
+ return 0;
+}
+
+// Start processing the next available incoming packet
+
+// Returns the size of the packet in bytes, or 0 if no packets are available
+int UIPUDP::parsePacket(void) {
+ UIPEthernet.tick();
+ if(appdata.packet_in != NOBLOCK)
+ {
+ #ifdef UIPETHERNET_DEBUG_UDP
+ pc.print("udp parsePacket freeing previous packet: ");
+ pc.println(appdata.packet_in);
+ #endif ;
+ UIPEthernet.network.freeBlock(appdata.packet_in);
+ }
+
+ memhandle* packet = &appdata.packets_in[0];
+ appdata.packet_in = *packet;
+ if(appdata.packet_in != NOBLOCK)
+ {
+ #ifdef UIPETHERNET_DEBUG_UDP
+ pc.print("udp parsePacket received packet: ");
+ pc.print(appdata.packet_in);
+ #endif
+ if(UIP_UDP_NUMPACKETS > 1) {
+ uint8_t i = 1;
+ memhandle* p = packet + 1;
+freeloop:
+ *packet = *p;
+ if(*packet == NOBLOCK)
+ goto freeready;
+ packet++;
+ if(i < UIP_UDP_NUMPACKETS - 1) {
+ i++;
+ p++;
+ goto freeloop;
+ }
+ }
+
+ *packet = NOBLOCK;
+freeready:
+ int size = UIPEthernet.network.blockSize(appdata.packet_in);
+ #ifdef UIPETHERNET_DEBUG_UDP
+ pc.print(", size: ");
+ pc.println(size);
+ #endif
+ return size;
+ }
+
+ return 0;
+}
+
+// Number of bytes remaining in the current packet
+int UIPUDP::available(void) {
+ UIPEthernet.tick();
+ if(appdata.packet_in != NOBLOCK) {
+ return UIPEthernet.network.blockSize(appdata.packet_in);
+ }
+
+ return 0;
+}
+
+// Read a single byte from the current packet
+int UIPUDP::read(void) {
+ unsigned char c;
+ if(read(&c, 1) > 0) {
+ return c;
+ }
+
+ return -1;
+}
+
+// Read up to len bytes from the current packet and place them into buffer
+
+// Returns the number of bytes read, or 0 if none are available
+int UIPUDP::read(unsigned char* buffer, size_t len) {
+ UIPEthernet.tick();
+ if(appdata.packet_in != NOBLOCK) {
+ int read = UIPEthernet.network.readPacket(appdata.packet_in, 0, buffer, len);
+ UIPEthernet.network.resizeBlock(appdata.packet_in, read);
+ return read;
+ }
+
+ return 0;
+}
+
+//int
+//UIPUDP::read(char* buffer, size_t len)
+//{
+// return read((unsigned char*) buffer, size_t len)
+//}
+
+// Return the next byte from the current packet without moving on to the next byte
+int UIPUDP::peek(void) {
+ UIPEthernet.tick();
+ if(appdata.packet_in != NOBLOCK) {
+ unsigned char c;
+ if(UIPEthernet.network.readPacket(appdata.packet_in, 0, &c, 1) == 1)
+ return c;
+ }
+
+ return -1;
+}
+
+// Finish reading the current packet
+void UIPUDP::flush(void) {
+ UIPEthernet.tick();
+ if(appdata.packet_in != NOBLOCK) {
+ UIPEthernet.network.freeBlock(appdata.packet_in);
+ appdata.packet_in = NOBLOCK;
+ }
+}
+
+// Return the IP address of the host who sent the current incoming packet
+IPAddress UIPUDP::remoteIP(void) {
+ return appdata.ripaddr;
+}
+
+// Return the port of the host who sent the current incoming packet
+uint16_t UIPUDP::remotePort(void) {
+ return appdata.rport;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPUDP::uip_callback(uip_udp_appstate_t* s) {
+ if(appdata_t * data = (appdata_t*)s->user) {
+ if(uip_newdata()) {
+ data->rport = ntohs(UDPBUF->srcport);
+ data->ripaddr = ip_addr_uip(UDPBUF->srcipaddr);
+
+ memhandle* packet = &data->packets_in[0];
+ uint8_t i = 0;
+ do
+ {
+ if(*packet == NOBLOCK) {
+ *packet = UIPEthernet.network.allocBlock(ntohs(UDPBUF->udplen) - UIP_UDPH_LEN);
+
+ //if we are unable to allocate memory the packet is dropped. udp doesn't guarantee packet delivery
+ if(*packet != NOBLOCK) {
+
+ //discard Linklevel and IP and udp-header and any trailing bytes:
+ UIPEthernet.network.copyPacket
+ (
+ *packet,
+ 0,
+ UIPEthernet.in_packet,
+ UIP_UDP_PHYH_LEN,
+ UIPEthernet.network.blockSize(*packet)
+ );
+ #ifdef UIPETHERNET_DEBUG_UDP
+ pc.print("udp, uip_newdata received packet: ");
+ pc.print(*packet);
+ pc.print(", slot: ");
+ pc.print(i);
+ pc.print(", size: ");
+ pc.println(UIPEthernet.network.blockSize(*packet));
+ #endif
+ break;
+ }
+ }
+
+ packet++;
+ i++;
+ } while(i < UIP_UDP_NUMPACKETS);
+ }
+
+ if(uip_poll() && data->send)
+ {
+ //set uip_slen (uip private) by calling uip_udp_send
+ #ifdef UIPETHERNET_DEBUG_UDP
+ pc.print("udp, uip_poll preparing packet to send: ");
+ pc.print(data->packet_out);
+ pc.print(", size: ");
+ pc.println(UIPEthernet.network.blockSize(data->packet_out));
+ #endif
+ UIPEthernet.uip_packet = data->packet_out;
+ data->packet_out = NOBLOCK;
+ UIPEthernet.uip_hdrlen = UIP_UDP_PHYH_LEN;
+ UIPEthernet.packetstate |= UIPETHERNET_SENDPACKET;
+ uip_udp_send(data->out_pos - (UIP_UDP_PHYH_LEN));
+ uip_process(UIP_UDP_SEND_CONN); //generate udp + ip headers
+ uip_arp_out(); //add arp
+ if(uip_len == UIP_ARPHDRSIZE) {
+ UIPEthernet.packetstate &= ~UIPETHERNET_SENDPACKET;
+ #ifdef UIPETHERNET_DEBUG_UDP
+ pc.println("udp, uip_poll results in ARP-packet");
+ #endif
+ }
+ else {
+
+ //arp found ethaddr for ip (otherwise packet is replaced by arp-request)
+ data->send = false;
+ #ifdef UIPETHERNET_DEBUG_UDP
+ pc.print("udp, uip_packet to send: ");
+ pc.println(UIPEthernet.uip_packet);
+ #endif
+ }
+ }
+ }
+}
+#endif
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/UIPUdp.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,108 @@
+/*
+ UIPUdp.h - 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/>.
+ */
+#ifndef UIPUDP_H
+ #define UIPUDP_H
+
+ #include "ethernet_comp.h"
+ #include "mbed.h"
+ #include <Udp.h>
+ #include "mempool.h"
+extern "C"
+{
+ #include "uip.h"
+}
+ #define UIP_UDP_MAXDATALEN 1500
+ #define UIP_UDP_PHYH_LEN UIP_LLH_LEN + UIP_IPUDPH_LEN
+ #define UIP_UDP_MAXPACKETSIZE UIP_UDP_MAXDATALEN + UIP_UDP_PHYH_LEN
+ #ifndef UIP_UDP_NUMPACKETS
+ #define UIP_UDP_NUMPACKETS 5
+ #endif
+class UIPUDP :
+ public UDP
+{
+private:
+ struct uip_udp_conn* _uip_udp_conn;
+
+ struct appdata_t
+ {
+ uint16_t rport;
+ IPAddress ripaddr;
+ memaddress out_pos;
+ memhandle packets_in[UIP_UDP_NUMPACKETS];
+ memhandle packet_in;
+ memhandle packet_out;
+ bool send;
+ } appdata;
+public:
+ UIPUDP(void); // Constructor
+ uint8_t begin(uint16_t); // initialize, start listening on specified port. Returns 1 if successful, 0 if there are no sockets available to use
+ void stop(void); // Finish with the UDP socket
+
+ // Sending UDP packets
+ // Start building up a packet to send to the remote host specific in ip and port
+ // Returns 1 if successful, 0 if there was a problem with the supplied IP address or port
+ int beginPacket(IPAddress ip, uint16_t port);
+
+ // Start building up a packet to send to the remote host specific in host and port
+ // Returns 1 if successful, 0 if there was a problem resolving the hostname or port
+ int beginPacket(const char* host, uint16_t port);
+
+ // Finish off this packet and send it
+ // Returns 1 if the packet was sent successfully, 0 if there was an error
+ int endPacket(void);
+
+ // Write a single byte into the packet
+ size_t write(uint8_t);
+
+ // Write size bytes from buffer into the packet
+ size_t write(const uint8_t* buffer, size_t size);
+
+ // using Print::write;
+ // Start processing the next available incoming packet
+ // Returns the size of the packet in bytes, or 0 if no packets are available
+ int parsePacket(void);
+
+ // Number of bytes remaining in the current packet
+ int available(void);
+
+ // Read a single byte from the current packet
+ int read(void);
+
+ // Read up to len bytes from the current packet and place them into buffer
+ // Returns the number of bytes read, or 0 if none are available
+ int read(unsigned char* buffer, size_t len);
+ // Read up to len characters from the current packet and place them into buffer
+
+ // Returns the number of characters read, or 0 if none are available
+ int read(char* buffer, size_t len) { return read((unsigned char*)buffer, len); };
+
+ // Return the next byte from the current packet without moving on to the next byte
+ int peek(void);
+
+ void flush(void); // Finish reading the current packet
+
+ // Return the IP address of the host who sent the current incoming packet
+ IPAddress remoteIP(void);
+
+ // Return the port of the host who sent the current incoming packet
+ uint16_t remotePort(void);
+private:
+ static void uip_callback(uip_udp_appstate_t* s);
+};
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ethernet_comp.h Mon Sep 15 11:12:30 2014 +0000 @@ -0,0 +1,8 @@ +#ifndef ETHERNET_COMP_H + #define ETHERNET_COMP_H + + #define Ethernet UIPEthernet + #define EthernetClient UIPClient + #define EthernetServer UIPServer + #define EthernetUDP UIPUDP +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/Client.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,48 @@
+/*
+ Client.h - Base class that provides Client
+ Copyright (c) 2011 Adrian McEwen. All right reserved.
+
+ Modified (ported to mbed) by Zoltan Hudak <hudakz@inbox.com>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+#ifndef client_h
+ #define client_h
+ //#include "Print.h"
+ //#include "Stream.h"
+ #include "IPAddress.h"
+
+//class Client : public Stream {
+class Client
+{
+public:
+ virtual int connect(IPAddress ip, uint16_t port) = 0;
+ virtual int connect(const char* host, uint16_t port) = 0;
+ virtual size_t write(uint8_t) = 0;
+ virtual size_t write(const uint8_t* buf, size_t size) = 0;
+ virtual int available(void) = 0;
+ virtual int read(void) = 0;
+ virtual int read(uint8_t* buf, size_t size) = 0;
+ virtual int peek(void) = 0;
+ virtual void flush(void) = 0;
+ virtual void stop(void) = 0;
+ virtual uint8_t connected(void) = 0;
+ virtual operator bool(void) = 0;
+protected:
+ uint8_t* rawIPAddress(IPAddress& addr) { return addr.raw_address(); };
+};
+#endif
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/Enc28J60Network.cpp Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,695 @@
+/*
+ Enc28J60Network.h
+ UIPEthernet network driver for Microchip ENC28J60 Ethernet Interface.
+
+ Copyright (c) 2013 Norbert Truchsess <norbert.truchsess@t-online.de>
+ All rights reserved.
+
+ based on enc28j60.c file from the AVRlib library by Pascal Stang.
+ For AVRlib See http://www.procyonengineering.com/
+
+ Modified (ported to mbed) by Zoltan Hudak <hudakz@inbox.com>
+
+ 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/>.
+ */
+#include "Enc28J60Network.h"
+#include "mbed.h"
+
+extern "C"
+{
+#include "enc28j60.h"
+#include "uip.h"
+}
+#define DMARUNNING 1
+#define DMANEWPACKET 2
+
+#define waitspi() while(!(SPSR & (1 << SPIF)))
+ Enc28J60Network::Enc28J60Network(PinName mosi, PinName miso, PinName sclk, PinName cs) :
+ MemoryPool(TXSTART_INIT + 1, TXSTOP_INIT - TXSTART_INIT),
+
+ // 1 byte in between RX_STOP_INIT and pool to allow prepending of controlbyte
+ bank(0xff),
+ _spi(mosi, miso, sclk),
+ _cs(cs) { }
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void Enc28J60Network::init(uint8_t* macaddr) {
+
+ // initialize SPI interface
+
+ _spi.format(8, 0); // 8bit, mode 0
+ _spi.frequency(7000000); // 7MHz
+ wait(1); // 1 second for stable state
+
+ // initialize I/O
+ _cs = 1; // ss=0
+
+ // initialize SPI interface
+ // master mode and Fosc/2 clock:
+ //SPCR = (1<<SPE)|(1<<MSTR);
+ //SPSR |= (1<<SPI2X);
+ // perform system reset
+ writeOp(ENC28J60_SOFT_RESET, 0, ENC28J60_SOFT_RESET);
+ wait(0.020); // 20ms
+
+ // check CLKRDY bit to see if reset is complete
+ // The CLKRDY does not work. See Rev. B4 Silicon Errata point. Just wait.
+ //while(!(readReg(ESTAT) & ESTAT_CLKRDY));
+ // do bank 0 stuff
+ // initialize receive buffer
+ // 16-bit transfers, must write low byte first
+ // set receive buffer start address
+ nextPacketPtr = RXSTART_INIT;
+
+ // Rx start
+ writeRegPair(ERXSTL, RXSTART_INIT);
+
+ // set receive pointer address
+ writeRegPair(ERXRDPTL, RXSTART_INIT);
+
+ // RX end
+ writeRegPair(ERXNDL, RXSTOP_INIT);
+
+ // TX start
+ //writeRegPair(ETXSTL, TXSTART_INIT);
+ // TX end
+ //writeRegPair(ETXNDL, TXSTOP_INIT);
+ // do bank 1 stuff, packet filter:
+ // For broadcast packets we allow only ARP packtets
+ // All other packets should be unicast only for our mac (MAADR)
+ //
+ // The pattern to match on is therefore
+ // Type ETH.DST
+ // ARP BROADCAST
+ // 06 08 -- ff ff ff ff ff ff -> ip checksum for theses bytes=f7f9
+ // in binary these poitions are:11 0000 0011 1111
+ // This is hex 303F->EPMM0=0x3f,EPMM1=0x30
+ //TODO define specific pattern to receive dhcp-broadcast packages instead of setting ERFCON_BCEN!
+ writeReg(ERXFCON, ERXFCON_UCEN | ERXFCON_CRCEN | ERXFCON_PMEN | ERXFCON_BCEN);
+ writeRegPair(EPMM0, 0x303f);
+ writeRegPair(EPMCSL, 0xf7f9);
+
+ //
+ //
+ // do bank 2 stuff
+ // enable MAC receive
+ // and bring MAC out of reset (writes 0x00 to MACON2)
+ writeRegPair(MACON1, MACON1_MARXEN | MACON1_TXPAUS | MACON1_RXPAUS);
+
+ // enable automatic padding to 60bytes and CRC operations
+ writeOp(ENC28J60_BIT_FIELD_SET, MACON3, MACON3_PADCFG0 | MACON3_TXCRCEN | MACON3_FRMLNEN);
+
+ // set inter-frame gap (non-back-to-back)
+ writeRegPair(MAIPGL, 0x0C12);
+
+ // set inter-frame gap (back-to-back)
+ writeReg(MABBIPG, 0x12);
+
+ // Set the maximum packet size which the controller will accept
+ // Do not send packets longer than MAX_FRAMELEN:
+ writeRegPair(MAMXFLL, MAX_FRAMELEN);
+
+ // do bank 3 stuff
+ // write MAC address
+ // NOTE: MAC address in ENC28J60 is byte-backward
+ writeReg(MAADR5, macaddr[0]);
+ writeReg(MAADR4, macaddr[1]);
+ writeReg(MAADR3, macaddr[2]);
+ writeReg(MAADR2, macaddr[3]);
+ writeReg(MAADR1, macaddr[4]);
+ writeReg(MAADR0, macaddr[5]);
+
+ // no loopback of transmitted frames
+ phyWrite(PHCON2, PHCON2_HDLDIS);
+
+ // switch to bank 0
+ setBank(ECON1);
+
+ // enable interrutps
+ writeOp(ENC28J60_BIT_FIELD_SET, EIE, EIE_INTIE | EIE_PKTIE);
+
+ // enable packet reception
+ writeOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_RXEN);
+ clkout(2); // change clkout from 6.25MHz to 12.5MHz
+ wait(0.000060); // 60us
+
+ //Configure leds
+ phyWrite(PHLCON, 0x476);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+memhandle Enc28J60Network::receivePacket(void) {
+ uint16_t rxstat;
+ uint16_t len;
+ // check if a packet has been received and buffered
+
+ //if( !(readReg(EIR) & EIR_PKTIF) ){
+ // The above does not work. See Rev. B4 Silicon Errata point 6.
+ if(readReg(EPKTCNT) != 0) {
+ uint16_t readPtr = nextPacketPtr + 6;
+ // Set the read pointer to the start of the received packet
+
+ writeRegPair(ERDPTL, nextPacketPtr);
+
+ // read the next packet pointer
+ nextPacketPtr = readOp(ENC28J60_READ_BUF_MEM, 0);
+ nextPacketPtr |= readOp(ENC28J60_READ_BUF_MEM, 0) << 8;
+
+ // read the packet length (see datasheet page 43)
+ len = readOp(ENC28J60_READ_BUF_MEM, 0);
+ len |= readOp(ENC28J60_READ_BUF_MEM, 0) << 8;
+ len -= 4; //remove the CRC count
+
+ // read the receive status (see datasheet page 43)
+ rxstat = readOp(ENC28J60_READ_BUF_MEM, 0);
+ rxstat |= readOp(ENC28J60_READ_BUF_MEM, 0) << 8;
+
+ // decrement the packet counter indicate we are done with this packet
+ writeOp(ENC28J60_BIT_FIELD_SET, ECON2, ECON2_PKTDEC);
+
+ // check CRC and symbol errors (see datasheet page 44, table 7-3):
+ // The ERXFCON.CRCEN is set by default. Normally we should not
+ // need to check this.
+ if((rxstat & 0x80) != 0) {
+ receivePkt.begin = readPtr;
+ receivePkt.size = len;
+ return UIP_RECEIVEBUFFERHANDLE;
+ }
+
+ // Move the RX read pointer to the start of the next received packet
+ // This frees the memory we just read out
+ setERXRDPT();
+ }
+
+ return(NOBLOCK);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void Enc28J60Network::setERXRDPT(void) {
+ writeRegPair(ERXRDPTL, nextPacketPtr == RXSTART_INIT ? RXSTOP_INIT : nextPacketPtr - 1);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+memaddress Enc28J60Network::blockSize(memhandle handle) {
+ return handle == UIP_RECEIVEBUFFERHANDLE ? receivePkt.size : blocks[handle].size;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void Enc28J60Network::sendPacket(memhandle handle) {
+ memblock* packet = &blocks[handle];
+ uint16_t start = packet->begin - 1;
+ uint16_t end = start + packet->size;
+
+ // backup data at control-byte position
+ uint8_t data = readByte(start);
+ // write control-byte (if not 0 anyway)
+
+ if(data)
+ writeByte(start, 0);
+
+#ifdef ENC28J60DEBUG
+ pc.print("sendPacket(");
+ pc.print(handle);
+ pc.print(") [");
+ pc.print(start);
+ pc.print("-");
+ pc.print(end);
+ pc.println("]:");
+ for(uint16_t i = start; i <= end; i++) {
+ pc.print(readByte(i), HEX);
+ pc.print(" ");
+ }
+
+ pc.println();
+#endif
+ // TX start
+
+ writeRegPair(ETXSTL, start);
+
+ // Set the TXND pointer to correspond to the packet size given
+ writeRegPair(ETXNDL, end);
+
+ // send the contents of the transmit buffer onto the network
+ writeOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_TXRTS);
+
+ // Reset the transmit logic problem. See Rev. B4 Silicon Errata point 12.
+ if((readReg(EIR) & EIR_TXERIF)) {
+ writeOp(ENC28J60_BIT_FIELD_CLR, ECON1, ECON1_TXRTS);
+ }
+
+ //restore data on control-byte position
+ if(data)
+ writeByte(start, data);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+uint16_t Enc28J60Network::setReadPtr(memhandle handle, memaddress position, uint16_t len) {
+ memblock* packet = handle == UIP_RECEIVEBUFFERHANDLE ? &receivePkt : &blocks[handle];
+ memaddress start = packet->begin + position;
+
+ writeRegPair(ERDPTL, start);
+
+ if(len > packet->size - position)
+ len = packet->size - position;
+ return len;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+uint16_t Enc28J60Network::readPacket(memhandle handle, memaddress position, uint8_t* buffer, uint16_t len) {
+ len = setReadPtr(handle, position, len);
+ readBuffer(len, buffer);
+ return len;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+uint16_t Enc28J60Network::writePacket(memhandle handle, memaddress position, uint8_t* buffer, uint16_t len) {
+ memblock* packet = &blocks[handle];
+ uint16_t start = packet->begin + position;
+
+ writeRegPair(EWRPTL, start);
+
+ if(len > packet->size - position)
+ len = packet->size - position;
+ writeBuffer(len, buffer);
+ return len;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+uint8_t Enc28J60Network::readByte(uint16_t addr) {
+ uint8_t result;
+
+ writeRegPair(ERDPTL, addr);
+
+ _cs = 0;
+
+ // issue read command
+ _spi.write(ENC28J60_READ_BUF_MEM);
+
+ // read data
+ result = _spi.write(0x00);
+ _cs = 1;
+ return(result);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void Enc28J60Network::writeByte(uint16_t addr, uint8_t data) {
+ writeRegPair(EWRPTL, addr);
+
+ _cs = 0;
+
+ // issue write command
+ _spi.write(ENC28J60_WRITE_BUF_MEM);
+
+ // write data
+ _spi.write(data);
+ _cs = 1;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void Enc28J60Network::copyPacket
+(
+ memhandle dest_pkt,
+ memaddress dest_pos,
+ memhandle src_pkt,
+ memaddress src_pos,
+ uint16_t len
+) {
+ memblock* dest = &blocks[dest_pkt];
+ memblock* src = src_pkt == UIP_RECEIVEBUFFERHANDLE ? &receivePkt : &blocks[src_pkt];
+ memblock_mv_cb(dest->begin + dest_pos, src->begin + src_pos, len);
+
+ // Move the RX read pointer to the start of the next received packet
+ // This frees the memory we just read out
+ setERXRDPT();
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void Enc28J60Network::memblock_mv_cb(uint16_t dest, uint16_t src, uint16_t len) {
+
+ //as ENC28J60 DMA is unable to copy single bytes:
+
+ if(len == 1) {
+ writeByte(dest, readByte(src));
+ }
+ else {
+
+ // calculate address of last byte
+ len += src - 1;
+
+ /* 1. Appropriately program the EDMAST, EDMAND
+ and EDMADST register pairs. The EDMAST
+ registers should point to the first byte to copy
+ from, the EDMAND registers should point to the
+ last byte to copy and the EDMADST registers
+ should point to the first byte in the destination
+ range. The destination range will always be
+ linear, never wrapping at any values except from
+ 8191 to 0 (the 8-Kbyte memory boundary).
+ Extreme care should be taken when
+ programming the start and end pointers to
+ prevent a never ending DMA operation which
+ would overwrite the entire 8-Kbyte buffer.
+ */
+ writeRegPair(EDMASTL, src);
+ writeRegPair(EDMADSTL, dest);
+
+ if((src <= RXSTOP_INIT) && (len > RXSTOP_INIT))
+ len -= (RXSTOP_INIT - RXSTART_INIT);
+ writeRegPair(EDMANDL, len);
+
+ /*
+ 2. If an interrupt at the end of the copy process is
+ desired, set EIE.DMAIE and EIE.INTIE and
+ clear EIR.DMAIF.
+
+ 3. Verify that ECON1.CSUMEN is clear. */
+ writeOp(ENC28J60_BIT_FIELD_CLR, ECON1, ECON1_CSUMEN);
+
+ /* 4. Start the DMA copy by setting ECON1.DMAST. */
+ writeOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_DMAST);
+
+ // wait until runnig DMA is completed
+ while(readOp(ENC28J60_READ_CTRL_REG, ECON1) & ECON1_DMAST);
+ }
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void Enc28J60Network::freePacket(void) {
+ setERXRDPT();
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+uint8_t Enc28J60Network::readOp(uint8_t op, uint8_t address) {
+ uint8_t result;
+
+ _cs = 0;
+
+ // issue read command
+ _spi.write(op | (address & ADDR_MASK));
+
+ // read data
+ result = _spi.write(0x00);
+
+ // do dummy read if needed (for mac and mii, see datasheet page 29)
+ if(address & 0x80)
+ result = _spi.write(0x00);
+
+ // release CS
+ _cs = 1;
+ return(result);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void Enc28J60Network::writeOp(uint8_t op, uint8_t address, uint8_t data) {
+ _cs = 0;
+
+ // issue write command
+ _spi.write(op | (address & ADDR_MASK));
+
+ // write data
+ _spi.write(data);
+ _cs = 1;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void Enc28J60Network::readBuffer(uint16_t len, uint8_t* data) {
+ _cs = 0;
+
+ // issue read command
+ _spi.write(ENC28J60_READ_BUF_MEM);
+ while(len) {
+ len--;
+
+ // read data
+ *data = _spi.write(0x00);
+ data++;
+ }
+
+ *data = '\0';
+ _cs = 1;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void Enc28J60Network::writeBuffer(uint16_t len, uint8_t* data) {
+ _cs = 0;
+
+ // issue write command
+ _spi.write(ENC28J60_WRITE_BUF_MEM);
+ while(len) {
+ len--;
+
+ // write data
+ _spi.write(*data);
+ data++;
+ }
+
+ _cs = 1;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void Enc28J60Network::setBank(uint8_t address) {
+
+ // set the bank (if needed)
+
+ if((address & BANK_MASK) != bank) {
+
+ // set the bank
+ writeOp(ENC28J60_BIT_FIELD_CLR, ECON1, (ECON1_BSEL1 | ECON1_BSEL0));
+ writeOp(ENC28J60_BIT_FIELD_SET, ECON1, (address & BANK_MASK) >> 5);
+ bank = (address & BANK_MASK);
+ }
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+uint8_t Enc28J60Network::readReg(uint8_t address) {
+
+ // set the bank
+
+ setBank(address);
+
+ // do the read
+ return readOp(ENC28J60_READ_CTRL_REG, address);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void Enc28J60Network::writeReg(uint8_t address, uint8_t data) {
+
+ // set the bank
+
+ setBank(address);
+
+ // do the write
+ writeOp(ENC28J60_WRITE_CTRL_REG, address, data);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void Enc28J60Network::writeRegPair(uint8_t address, uint16_t data) {
+
+ // set the bank
+
+ setBank(address);
+
+ // do the write
+ writeOp(ENC28J60_WRITE_CTRL_REG, address, (data & 0xFF));
+ writeOp(ENC28J60_WRITE_CTRL_REG, address + 1, (data) >> 8);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void Enc28J60Network::phyWrite(uint8_t address, uint16_t data) {
+
+ // set the PHY register address
+
+ writeReg(MIREGADR, address);
+
+ // write the PHY data
+ writeRegPair(MIWRL, data);
+
+ // wait until the PHY write completes
+ while(readReg(MISTAT) & MISTAT_BUSY) {
+ wait(0.000015);
+ }
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void Enc28J60Network::clkout(uint8_t clk) {
+
+ //setup clkout: 2 is 12.5MHz:
+
+ writeReg(ECOCON, clk & 0x7);
+}
+
+// read the revision of the chip:
+uint8_t Enc28J60Network::getRev(void) {
+ return(readReg(EREVID));
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+uint16_t Enc28J60Network::chksum(uint16_t sum, memhandle handle, memaddress pos, uint16_t len) {
+ uint8_t spdr;
+ uint16_t t;
+ uint16_t i;
+
+ len = setReadPtr(handle, pos, len) - 1;
+ _cs = 0;
+
+ // issue read command
+ spdr = _spi.write(ENC28J60_READ_BUF_MEM);
+ for(i = 0; i < len; i += 2) {
+
+ // read data
+ spdr = _spi.write(0x00);
+ t = spdr << 8;
+ spdr = _spi.write(0x00);
+ t += spdr;
+ sum += t;
+ if(sum < t) {
+ sum++; /* carry */
+ }
+ }
+
+ if(i == len) {
+ spdr = _spi.write(0x00);
+ t = (spdr << 8) + 0;
+ sum += t;
+ if(sum < t) {
+ sum++; /* carry */
+ }
+ }
+
+ _cs = 1;
+
+ /* Return sum in host byte order. */
+ return sum;
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/Enc28J60Network.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,81 @@
+/*
+ Enc28J60Network.h
+ UIPEthernet network driver for Microchip ENC28J60 Ethernet Interface.
+
+ Copyright (c) 2013 Norbert Truchsess <norbert.truchsess@t-online.de>
+ All rights reserved.
+
+ inspired by enc28j60.c file from the AVRlib library by Pascal Stang.
+ For AVRlib See http://www.procyonengineering.com/
+
+ Modified (ported to mbed) by Zoltan Hudak <hudakz@inbox.com>
+
+ 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/>.
+ */
+#ifndef ENC28J60NETWORK_H_
+ #define ENC28J60NETWORK_H_
+
+ #include "mbed.h"
+ #include "mempool.h"
+
+ #define UIP_RECEIVEBUFFERHANDLE 0xff
+
+//#define ENC28J60DEBUG
+
+/*
+ * Received from ip-header, arp etc...
+ * when tcp/udp -> tcp/udp-callback -> assign new packet to connection
+ */
+class Enc28J60Network :
+ public MemoryPool
+{
+private:
+ SPI _spi;
+ DigitalOut _cs;
+ uint16_t nextPacketPtr;
+ uint8_t bank;
+
+ struct memblock receivePkt;
+
+ uint8_t readOp(uint8_t op, uint8_t address);
+ void writeOp(uint8_t op, uint8_t address, uint8_t data);
+ uint16_t setReadPtr(memhandle handle, memaddress position, uint16_t len);
+ void setERXRDPT(void);
+ void readBuffer(uint16_t len, uint8_t* data);
+ void writeBuffer(uint16_t len, uint8_t* data);
+ uint8_t readByte(uint16_t addr);
+ void writeByte(uint16_t addr, uint8_t data);
+ void setBank(uint8_t address);
+ uint8_t readReg(uint8_t address);
+ void writeReg(uint8_t address, uint8_t data);
+ void writeRegPair(uint8_t address, uint16_t data);
+ void phyWrite(uint8_t address, uint16_t data);
+ void clkout(uint8_t clk);
+ uint8_t getRev(void);
+protected:
+ void memblock_mv_cb(memaddress dest, memaddress src, memaddress size);
+public:
+ Enc28J60Network(PinName mosi, PinName miso, PinName sclk, PinName cs);
+ void init(uint8_t* macaddr);
+ memhandle receivePacket(void);
+ void freePacket(void);
+ memaddress blockSize(memhandle handle);
+ void sendPacket(memhandle handle);
+ uint16_t readPacket(memhandle handle, memaddress position, uint8_t* buffer, uint16_t len);
+ uint16_t writePacket(memhandle handle, memaddress position, uint8_t* buffer, uint16_t len);
+ void copyPacket(memhandle dest, memaddress dest_pos, memhandle src, memaddress src_pos, uint16_t len);
+ uint16_t chksum(uint16_t sum, memhandle handle, memaddress pos, uint16_t len);
+};
+#endif /* ENC28J60NETWORK_H_ */
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/IPAddress.cpp Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,112 @@
+/*
+ IPAddress.cpp - Base class that provides IPAddress
+ Copyright (c) 2011 Adrian McEwen. All right reserved.
+
+ Modified (ported to mbed) by Zoltan Hudak <hudakz@inbox.com>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+#include <mbed.h>
+#include <IPAddress.h>
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+IPAddress::IPAddress(void) {
+ memset(_address, 0, sizeof(_address));
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+IPAddress::IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet) {
+ _address[0] = first_octet;
+ _address[1] = second_octet;
+ _address[2] = third_octet;
+ _address[3] = fourth_octet;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+IPAddress::IPAddress(uint32_t address) {
+ memcpy(_address, &address, sizeof(_address));
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+IPAddress::IPAddress(const uint8_t* address) {
+ memcpy(_address, address, sizeof(_address));
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+IPAddress &IPAddress::operator=(const uint8_t* address) {
+ memcpy(_address, address, sizeof(_address));
+ return *this;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+IPAddress &IPAddress::operator=(uint32_t address) {
+ memcpy(_address, (const uint8_t*) &address, sizeof(_address));
+ return *this;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+bool IPAddress::operator==(const uint8_t* addr) const
+{
+ return memcmp(addr, _address, sizeof(_address)) == 0;
+}
+
+//size_t IPAddress::printTo(Print& p) const
+//{
+// size_t n = 0;
+// for (int i =0; i < 3; i++)
+// {
+// n += p.print(_address[i], DEC);
+// n += p.print('.');
+// }
+// n += p.print(_address[3], DEC);
+// return n;
+//}
+//
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/IPAddress.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,73 @@
+/*
+ IPAddress.h - Base class that provides IPAddress
+ Copyright (c) 2011 Adrian McEwen. All right reserved.
+
+ Modified (ported to mbed) by Zoltan Hudak <hudakz@inbox.com>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+#ifndef IPAddress_h
+ #define IPAddress_h
+
+ #include <stdint.h>
+
+//#include <Printable.h>
+
+// A class to make it easier to handle and pass around IP addresses
+
+//class IPAddress : public Printable {
+class IPAddress
+{
+private:
+ uint8_t _address[4]; // IPv4 address
+
+ // Access the raw byte array containing the address. Because this returns a pointer
+ // to the internal structure rather than a copy of the address this function should only
+ // be used when you know that the usage of the returned uint8_t* will be transient and not
+
+ // stored.
+ uint8_t* raw_address(void) { return _address; };
+public:
+ // Constructors
+ IPAddress(void);
+ IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet);
+ IPAddress(uint32_t address);
+ IPAddress(const uint8_t* address);
+
+ // Overloaded cast operator to allow IPAddress objects to be used where a pointer
+ // to a four-byte uint8_t array is expected
+ operator uint32_t(void) const { return *((uint32_t*)_address); };
+ bool operator==(const IPAddress& addr) const { return(*((uint32_t*)_address)) == (*((uint32_t*)addr._address)); };
+ bool operator==(const uint8_t* addr) const;
+
+ // Overloaded index operator to allow getting and setting individual octets of the address
+ uint8_t operator[](int index) const { return _address[index]; };
+ uint8_t &operator[](int index) { return _address[index]; };
+
+ // Overloaded copy operators to allow initialisation of IPAddress objects from other types
+ IPAddress &operator =(const uint8_t* address);
+ IPAddress &operator =(uint32_t address);
+
+ // virtual size_t printTo(Print& p) const;
+ friend class EthernetClass;
+ friend class UDP;
+ friend class Client;
+ friend class Server;
+ friend class DhcpClass;
+ friend class DNSClient;
+};
+
+const IPAddress INADDR_NONE(0, 0, 0, 0);
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/Server.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,30 @@
+/*
+ Server.h - Base class that provides Server
+ Copyright (c) 2011 Adrian McEwen. All right reserved.
+
+ Modified (ported to mbed) by Zoltan Hudak <hudakz@inbox.com>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+#ifndef server_h
+ #define server_h
+
+//class Server : public Print {
+class Server
+{
+public:
+ virtual void begin(void) = 0;
+};
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/Udp.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,96 @@
+/*
+ * Udp.cpp: Library to send/receive UDP packets.
+ *
+ * NOTE: UDP is fast, but has some important limitations (thanks to Warren Gray for mentioning these)
+ * 1) UDP does not guarantee the order in which assembled UDP packets are received. This
+ * might not happen often in practice, but in larger network topologies, a UDP
+ * packet can be received out of sequence.
+ * 2) UDP does not guard against lost packets - so packets *can* disappear without the sender being
+ * aware of it. Again, this may not be a concern in practice on small local networks.
+ * For more information, see http://www.cafeaulait.org/course/week12/35.html
+ *
+ * MIT License:
+ * Copyright (c) 2008 Bjoern Hartmann
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * bjoern@cs.stanford.edu 12/30/2008
+ */
+#ifndef udp_h
+ #define udp_h
+
+ #include <mbed.h>
+ #include <IPAddress.h>
+
+//class UDP : public Stream {
+class UDP
+{
+public:
+ virtual uint8_t begin(uint16_t) = 0; // initialize, start listening on specified port. Returns 1 if successful, 0 if there are no sockets available to use
+ virtual void stop(void) = 0; // Finish with the UDP socket
+
+ // Sending UDP packets
+ // Start building up a packet to send to the remote host specific in ip and port
+ // Returns 1 if successful, 0 if there was a problem with the supplied IP address or port
+ virtual int beginPacket(IPAddress ip, uint16_t port) = 0;
+
+ // Start building up a packet to send to the remote host specific in host and port
+ // Returns 1 if successful, 0 if there was a problem resolving the hostname or port
+ virtual int beginPacket(const char* host, uint16_t port) = 0;
+
+ // Finish off this packet and send it
+ // Returns 1 if the packet was sent successfully, 0 if there was an error
+ virtual int endPacket(void) = 0;
+
+ // Write a single byte into the packet
+ virtual size_t write(uint8_t) = 0;
+
+ // Write size bytes from buffer into the packet
+ virtual size_t write(const uint8_t* buffer, size_t size) = 0;
+
+ // Start processing the next available incoming packet
+ // Returns the size of the packet in bytes, or 0 if no packets are available
+ virtual int parsePacket(void) = 0;
+
+ // Number of bytes remaining in the current packet
+ virtual int available(void) = 0;
+
+ // Read a single byte from the current packet
+ virtual int read(void) = 0;
+
+ // Read up to len bytes from the current packet and place them into buffer
+ // Returns the number of bytes read, or 0 if none are available
+ virtual int read(unsigned char* buffer, size_t len) = 0;
+
+ // Read up to len characters from the current packet and place them into buffer
+ // Returns the number of characters read, or 0 if none are available
+ virtual int read(char* buffer, size_t len) = 0;
+
+ // Return the next byte from the current packet without moving on to the next byte
+ virtual int peek(void) = 0;
+ virtual void flush(void) = 0; // Finish reading the current packet
+
+ // Return the IP address of the host who sent the current incoming packet
+ virtual IPAddress remoteIP(void) = 0;
+
+ // Return the port of the host who sent the current incoming packet
+ virtual uint16_t remotePort(void) = 0;
+protected:
+ uint8_t* rawIPAddress(IPAddress& addr) { return addr.raw_address(); };
+};
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/clock-arch.c Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,35 @@
+/*
+ clock-arch.c - mbed implementation of uIP clock device.
+ Copyright (c) 2010 Adam Nielsen <malvineous@shikadi.net>
+ All rights reserved.
+
+ Modified (ported to mbed) by Zoltan Hudak <hudakz@inbox.com>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#include <time.h>
+#include "clock-arch.h"
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+clock_time_t clock_time(void) {
+ return(clock_time_t) time(NULL);
+}
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uitility/clock-arch.h Mon Sep 15 11:12:30 2014 +0000 @@ -0,0 +1,25 @@ +/* + clock-arch.h - mbed implementation of uIP clock device. + Copyright (c) 2010 Adam Nielsen <malvineous@shikadi.net> + All rights reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ +#ifndef clock_h_ + #define clock_h_ + +typedef unsigned long clock_time_t; + #define CLOCK_CONF_SECOND 1 +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uitility/enc28j60.h Mon Sep 15 11:12:30 2014 +0000 @@ -0,0 +1,283 @@ +/***************************************************************************** +* +* Title : Microchip ENC28J60 Ethernet Interface Driver +* Author : Pascal Stang (c)2005 +* Modified by Norbert Truchsess +* Copyright: GPL V2 +* +*This driver provides initialization and transmit/receive +*functions for the Microchip ENC28J60 10Mb Ethernet Controller and PHY. +*This chip is novel in that it is a full MAC+PHY interface all in a 28-pin +*chip, using an SPI interface to the host processor. +* +* +*****************************************************************************/ +#ifndef ENC28J60_H + #define ENC28J60_H + #include <inttypes.h> + +// ENC28J60 Control Registers + +// Control register definitions are a combination of address, +// bank number, and Ethernet/MAC/PHY indicator bits. +// - Register address (bits 0-4) +// - Bank number (bits 5-6) +// - MAC/PHY indicator (bit 7) + #define ADDR_MASK 0x1F + #define BANK_MASK 0x60 + #define SPRD_MASK 0x80 +// All-bank registers + + #define EIE 0x1B + #define EIR 0x1C + #define ESTAT 0x1D + #define ECON2 0x1E + #define ECON1 0x1F +// Bank 0 registers + + #define ERDPTL (0x00 | 0x00) + #define ERDPTH (0x01 | 0x00) + #define EWRPTL (0x02 | 0x00) + #define EWRPTH (0x03 | 0x00) + #define ETXSTL (0x04 | 0x00) + #define ETXSTH (0x05 | 0x00) + #define ETXNDL (0x06 | 0x00) + #define ETXNDH (0x07 | 0x00) + #define ERXSTL (0x08 | 0x00) + #define ERXSTH (0x09 | 0x00) + #define ERXNDL (0x0A | 0x00) + #define ERXNDH (0x0B | 0x00) + #define ERXRDPTL (0x0C | 0x00) + #define ERXRDPTH (0x0D | 0x00) + #define ERXWRPTL (0x0E | 0x00) + #define ERXWRPTH (0x0F | 0x00) + #define EDMASTL (0x10 | 0x00) + #define EDMASTH (0x11 | 0x00) + #define EDMANDL (0x12 | 0x00) + #define EDMANDH (0x13 | 0x00) + #define EDMADSTL (0x14 | 0x00) + #define EDMADSTH (0x15 | 0x00) + #define EDMACSL (0x16 | 0x00) + #define EDMACSH (0x17 | 0x00) +// Bank 1 registers + + #define EHT0 (0x00 | 0x20) + #define EHT1 (0x01 | 0x20) + #define EHT2 (0x02 | 0x20) + #define EHT3 (0x03 | 0x20) + #define EHT4 (0x04 | 0x20) + #define EHT5 (0x05 | 0x20) + #define EHT6 (0x06 | 0x20) + #define EHT7 (0x07 | 0x20) + #define EPMM0 (0x08 | 0x20) + #define EPMM1 (0x09 | 0x20) + #define EPMM2 (0x0A | 0x20) + #define EPMM3 (0x0B | 0x20) + #define EPMM4 (0x0C | 0x20) + #define EPMM5 (0x0D | 0x20) + #define EPMM6 (0x0E | 0x20) + #define EPMM7 (0x0F | 0x20) + #define EPMCSL (0x10 | 0x20) + #define EPMCSH (0x11 | 0x20) + #define EPMOL (0x14 | 0x20) + #define EPMOH (0x15 | 0x20) + #define EWOLIE (0x16 | 0x20) + #define EWOLIR (0x17 | 0x20) + #define ERXFCON (0x18 | 0x20) + #define EPKTCNT (0x19 | 0x20) +// Bank 2 registers + + #define MACON1 (0x00 | 0x40 | 0x80) + #define MACON2 (0x01 | 0x40 | 0x80) + #define MACON3 (0x02 | 0x40 | 0x80) + #define MACON4 (0x03 | 0x40 | 0x80) + #define MABBIPG (0x04 | 0x40 | 0x80) + #define MAIPGL (0x06 | 0x40 | 0x80) + #define MAIPGH (0x07 | 0x40 | 0x80) + #define MACLCON1 (0x08 | 0x40 | 0x80) + #define MACLCON2 (0x09 | 0x40 | 0x80) + #define MAMXFLL (0x0A | 0x40 | 0x80) + #define MAMXFLH (0x0B | 0x40 | 0x80) + #define MAPHSUP (0x0D | 0x40 | 0x80) + #define MICON (0x11 | 0x40 | 0x80) + #define MICMD (0x12 | 0x40 | 0x80) + #define MIREGADR (0x14 | 0x40 | 0x80) + #define MIWRL (0x16 | 0x40 | 0x80) + #define MIWRH (0x17 | 0x40 | 0x80) + #define MIRDL (0x18 | 0x40 | 0x80) + #define MIRDH (0x19 | 0x40 | 0x80) +// Bank 3 registers + + #define MAADR1 (0x00 | 0x60 | 0x80) + #define MAADR0 (0x01 | 0x60 | 0x80) + #define MAADR3 (0x02 | 0x60 | 0x80) + #define MAADR2 (0x03 | 0x60 | 0x80) + #define MAADR5 (0x04 | 0x60 | 0x80) + #define MAADR4 (0x05 | 0x60 | 0x80) + #define EBSTSD (0x06 | 0x60) + #define EBSTCON (0x07 | 0x60) + #define EBSTCSL (0x08 | 0x60) + #define EBSTCSH (0x09 | 0x60) + #define MISTAT (0x0A | 0x60 | 0x80) + #define EREVID (0x12 | 0x60) + #define ECOCON (0x15 | 0x60) + #define EFLOCON (0x17 | 0x60) + #define EPAUSL (0x18 | 0x60) + #define EPAUSH (0x19 | 0x60) +// PHY registers + + #define PHCON1 0x00 + #define PHSTAT1 0x01 + #define PHHID1 0x02 + #define PHHID2 0x03 + #define PHCON2 0x10 + #define PHSTAT2 0x11 + #define PHIE 0x12 + #define PHIR 0x13 + #define PHLCON 0x14 + +// ENC28J60 ERXFCON Register Bit Definitions + + #define ERXFCON_UCEN 0x80 + #define ERXFCON_ANDOR 0x40 + #define ERXFCON_CRCEN 0x20 + #define ERXFCON_PMEN 0x10 + #define ERXFCON_MPEN 0x08 + #define ERXFCON_HTEN 0x04 + #define ERXFCON_MCEN 0x02 + #define ERXFCON_BCEN 0x01 +// ENC28J60 EIE Register Bit Definitions + + #define EIE_INTIE 0x80 + #define EIE_PKTIE 0x40 + #define EIE_DMAIE 0x20 + #define EIE_LINKIE 0x10 + #define EIE_TXIE 0x08 + #define EIE_WOLIE 0x04 + #define EIE_TXERIE 0x02 + #define EIE_RXERIE 0x01 +// ENC28J60 EIR Register Bit Definitions + + #define EIR_PKTIF 0x40 + #define EIR_DMAIF 0x20 + #define EIR_LINKIF 0x10 + #define EIR_TXIF 0x08 + #define EIR_WOLIF 0x04 + #define EIR_TXERIF 0x02 + #define EIR_RXERIF 0x01 +// ENC28J60 ESTAT Register Bit Definitions + + #define ESTAT_INT 0x80 + #define ESTAT_LATECOL 0x10 + #define ESTAT_RXBUSY 0x04 + #define ESTAT_TXABRT 0x02 + #define ESTAT_CLKRDY 0x01 +// ENC28J60 ECON2 Register Bit Definitions + + #define ECON2_AUTOINC 0x80 + #define ECON2_PKTDEC 0x40 + #define ECON2_PWRSV 0x20 + #define ECON2_VRPS 0x08 +// ENC28J60 ECON1 Register Bit Definitions + + #define ECON1_TXRST 0x80 + #define ECON1_RXRST 0x40 + #define ECON1_DMAST 0x20 + #define ECON1_CSUMEN 0x10 + #define ECON1_TXRTS 0x08 + #define ECON1_RXEN 0x04 + #define ECON1_BSEL1 0x02 + #define ECON1_BSEL0 0x01 +// ENC28J60 MACON1 Register Bit Definitions + + #define MACON1_LOOPBK 0x10 + #define MACON1_TXPAUS 0x08 + #define MACON1_RXPAUS 0x04 + #define MACON1_PASSALL 0x02 + #define MACON1_MARXEN 0x01 +// ENC28J60 MACON2 Register Bit Definitions + + #define MACON2_MARST 0x80 + #define MACON2_RNDRST 0x40 + #define MACON2_MARXRST 0x08 + #define MACON2_RFUNRST 0x04 + #define MACON2_MATXRST 0x02 + #define MACON2_TFUNRST 0x01 +// ENC28J60 MACON3 Register Bit Definitions + + #define MACON3_PADCFG2 0x80 + #define MACON3_PADCFG1 0x40 + #define MACON3_PADCFG0 0x20 + #define MACON3_TXCRCEN 0x10 + #define MACON3_PHDRLEN 0x08 + #define MACON3_HFRMLEN 0x04 + #define MACON3_FRMLNEN 0x02 + #define MACON3_FULDPX 0x01 +// ENC28J60 MICMD Register Bit Definitions + + #define MICMD_MIISCAN 0x02 + #define MICMD_MIIRD 0x01 +// ENC28J60 MISTAT Register Bit Definitions + + #define MISTAT_NVALID 0x04 + #define MISTAT_SCAN 0x02 + #define MISTAT_BUSY 0x01 +// ENC28J60 PHY PHCON1 Register Bit Definitions + + #define PHCON1_PRST 0x8000 + #define PHCON1_PLOOPBK 0x4000 + #define PHCON1_PPWRSV 0x0800 + #define PHCON1_PDPXMD 0x0100 +// ENC28J60 PHY PHSTAT1 Register Bit Definitions + + #define PHSTAT1_PFDPX 0x1000 + #define PHSTAT1_PHDPX 0x0800 + #define PHSTAT1_LLSTAT 0x0004 + #define PHSTAT1_JBSTAT 0x0002 +// ENC28J60 PHY PHCON2 Register Bit Definitions + + #define PHCON2_FRCLINK 0x4000 + #define PHCON2_TXDIS 0x2000 + #define PHCON2_JABBER 0x0400 + #define PHCON2_HDLDIS 0x0100 + +// ENC28J60 Packet Control Byte Bit Definitions + + #define PKTCTRL_PHUGEEN 0x08 + #define PKTCTRL_PPADEN 0x04 + #define PKTCTRL_PCRCEN 0x02 + #define PKTCTRL_POVERRIDE 0x01 + +// SPI operation codes + + #define ENC28J60_READ_CTRL_REG 0x00 + #define ENC28J60_READ_BUF_MEM 0x3A + #define ENC28J60_WRITE_CTRL_REG 0x40 + #define ENC28J60_WRITE_BUF_MEM 0x7A + #define ENC28J60_BIT_FIELD_SET 0x80 + #define ENC28J60_BIT_FIELD_CLR 0xA0 + #define ENC28J60_SOFT_RESET 0xFF + +// The RXSTART_INIT should be zero. See Rev. B4 Silicon Errata + +// buffer boundaries applied to internal 8K ram +// the entire available packet buffer space is allocated +// +// start with recbuf at 0/ + #define RXSTART_INIT 0x0 +// receive buffer end. make sure this is an odd value ( See Rev. B1,B4,B5,B7 Silicon Errata 'Memory (Ethernet Buffer)') + + #define RXSTOP_INIT (0x1FFF - 0x1800) +// start TX buffer RXSTOP_INIT+1 + + #define TXSTART_INIT (RXSTOP_INIT + 1) +// stp TX buffer at end of mem + + #define TXSTOP_INIT 0x1FFF +// + +// max frame length which the conroller will accept: + #define MAX_FRAMELEN 1500 // (note: maximum ethernet frame length would be 1518) + +//#define MAX_FRAMELEN 600 +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/mempool.cpp Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,190 @@
+/*
+ mempool.cpp - sleek implementation of a memory pool
+ 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/>.
+ */
+#include "mempool.h"
+#include <string.h>
+
+#define POOLOFFSET 1
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+MemoryPool::MemoryPool(memaddress start, memaddress size) {
+ memset(&blocks[0], 0, sizeof(blocks));
+ blocks[POOLSTART].begin = start;
+ blocks[POOLSTART].size = 0;
+ blocks[POOLSTART].nextblock = NOBLOCK;
+ poolsize = size;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+memhandle MemoryPool::allocBlock(memaddress size) {
+ memblock* best = NULL;
+ memhandle cur = POOLSTART;
+ memblock* block = &blocks[POOLSTART];
+ memaddress bestsize = poolsize + 1;
+
+ do
+ {
+ memhandle next = block->nextblock;
+ memaddress freesize = (next == NOBLOCK ? blocks[POOLSTART].begin + poolsize : blocks[next].begin) -
+ block->begin -
+ block->size;
+ if(freesize == size) {
+ best = &blocks[cur];
+ goto found;
+ }
+
+ if(freesize > size && freesize < bestsize) {
+ bestsize = freesize;
+ best = &blocks[cur];
+ }
+
+ if(next == NOBLOCK) {
+ if(best)
+ goto found;
+ else
+ goto collect;
+ }
+
+ block = &blocks[next];
+ cur = next;
+ } while(true);
+
+collect:
+ {
+ cur = POOLSTART;
+ block = &blocks[POOLSTART];
+
+ memhandle next;
+ while((next = block->nextblock) != NOBLOCK) {
+ memaddress dest = block->begin + block->size;
+ memblock* nextblock = &blocks[next];
+ memaddress* src = &nextblock->begin;
+ if(dest != *src)
+ {
+#ifdef MEMBLOCK_MV
+ memblock_mv_cb(dest, *src, nextblock->size);
+#endif
+ *src = dest;
+ }
+
+ block = nextblock;
+ }
+
+ if(blocks[POOLSTART].begin + poolsize - block->begin - block->size >= size)
+ best = block;
+ else
+ goto notfound;
+ }
+
+found:
+ {
+ block = &blocks[POOLOFFSET];
+ for(cur = POOLOFFSET; cur < NUM_MEMBLOCKS + POOLOFFSET; cur++) {
+ if(block->size) {
+ block++;
+ continue;
+ }
+
+ memaddress address = best->begin + best->size;
+#ifdef MEMBLOCK_ALLOC
+ MEMBLOCK_ALLOC(address, size);
+#endif
+ block->begin = address;
+ block->size = size;
+ block->nextblock = best->nextblock;
+ best->nextblock = cur;
+ return cur;
+ }
+ }
+
+notfound:
+ return NOBLOCK;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void MemoryPool::freeBlock(memhandle handle) {
+ memblock* b = &blocks[POOLSTART];
+
+ do
+ {
+ memhandle next = b->nextblock;
+ if(next == handle) {
+ memblock* f = &blocks[next];
+#ifdef MEMBLOCK_FREE
+ MEMBLOCK_FREE(f->begin, f->size);
+#endif
+ b->nextblock = f->nextblock;
+ f->size = 0;
+ f->nextblock = NOBLOCK;
+ return;
+ }
+
+ if(next == NOBLOCK)
+ return;
+ b = &blocks[next];
+ } while(true);
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void MemoryPool::resizeBlock(memhandle handle, memaddress position) {
+ memblock* block = &blocks[handle];
+ block->begin += position;
+ block->size -= position;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void MemoryPool::resizeBlock(memhandle handle, memaddress position, memaddress size) {
+ memblock* block = &blocks[handle];
+ block->begin += position;
+ block->size = size;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+memaddress MemoryPool::blockSize(memhandle handle) {
+ return blocks[handle].size;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/mempool.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,65 @@
+/*
+ mempool.h - sleek implementation of a memory pool
+ 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/>.
+ */
+#ifndef MEMPOOL_H
+ #define MEMPOOL_H
+
+ #include <inttypes.h>
+
+ #define POOLSTART 0
+ #define NOBLOCK 0
+
+ #include "mempool_conf.h"
+
+//#ifdef MEMBLOCK_MV
+
+//#define memblock_mv_cb(dest,src,size) MEMBLOCK_MV(dest,src,size)
+//#endif
+ #ifdef MEMBLOCK_ALLOC
+ #define memblock_alloc_cb(address, size) MEMBLOCK_ALLOC(address, size)
+ #endif
+ #ifdef MEMBLOCK_FREE
+ #define memblock_free_cb(address, size) MEMBLOCK_FREE(address, size)
+ #endif
+struct memblock
+{
+ memaddress begin;
+ memaddress size;
+ memhandle nextblock;
+};
+
+class MemoryPool
+{
+ #ifdef MEMPOOLTEST_H
+ friend class MemoryPoolTest;
+ #endif
+protected:
+ memaddress poolsize;
+ struct memblock blocks[NUM_MEMBLOCKS + 1];
+ #ifdef MEMBLOCK_MV
+ virtual void memblock_mv_cb(memaddress dest, memaddress src, memaddress size) = 0;
+ #endif
+public:
+ MemoryPool(memaddress start, memaddress size);
+ memhandle allocBlock(memaddress);
+ void freeBlock(memhandle);
+ void resizeBlock(memhandle handle, memaddress position);
+ void resizeBlock(memhandle handle, memaddress position, memaddress size);
+ memaddress blockSize(memhandle);
+};
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/mempool_conf.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,25 @@
+#ifndef MEMPOOLCONF_H
+ #define MEMPOOLCONF_H
+ #include "uipethernet-conf.h"
+extern "C"
+{
+ #include "uipopt.h"
+}
+ #include <inttypes.h>
+
+typedef uint16_t memaddress;
+typedef uint8_t memhandle;
+
+ #if UIP_SOCKET_NUMPACKETS and UIP_CONNS
+ #define NUM_TCP_MEMBLOCKS (UIP_SOCKET_NUMPACKETS * 2) * UIP_CONNS
+ #else
+ #define NUM_TCP_MEMBLOCKS 0
+ #endif
+ #if UIP_UDP_NUMPACKETS and UIP_UDP_CONNS
+ #define NUM_UDP_MEMBLOCKS (UIP_UDP_NUMPACKETS + 1) * UIP_UDP_CONNS
+ #else
+ #define NUM_UDP_MEMBLOCKS 0
+ #endif
+ #define NUM_MEMBLOCKS (NUM_TCP_MEMBLOCKS + NUM_UDP_MEMBLOCKS)
+ #define MEMBLOCK_MV
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/uip-conf.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,190 @@
+/**
+ * UIPEthernet Project-specific configuration options
+ * Copyright (c) 2013 Norbert Truchsess <norbert.truchsess@t-online.de>
+ * @{
+ *
+ * uIP has a number of configuration options that can be overridden
+ * for each project. These are kept in a project-specific uip-conf.h
+ * file and all configuration names have the prefix UIP_CONF.
+ */
+/*
+ * Copyright (c) 2006, Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the Institute nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack
+ *
+ */
+#ifndef __UIP_CONF_H__
+ #define __UIP_CONF_H__
+
+ #include <inttypes.h>
+ #include "uipethernet-conf.h"
+
+/**
+ * 8 bit datatype
+ *
+ * This typedef defines the 8-bit type used throughout uIP.
+ *
+ * \hideinitializer
+ */
+typedef uint8_t u8_t;
+
+/**
+ * 16 bit datatype
+ *
+ * This typedef defines the 16-bit type used throughout uIP.
+ *
+ * \hideinitializer
+ */
+typedef uint16_t u16_t;
+
+/**
+ * Statistics datatype
+ *
+ * This typedef defines the dataype used for keeping statistics in
+ * uIP.
+ *
+ * \hideinitializer
+ */
+typedef unsigned short uip_stats_t;
+
+/**
+ * Maximum number of TCP connections.
+ * (see uipethernet-conf.h)
+ * \hideinitializer
+ *
+ * #define UIP_CONF_MAX_CONNECTIONS 4
+ */
+
+/**
+ * Maximum number of listening TCP ports.
+ *
+ * \hideinitializer
+ */
+ #define UIP_CONF_MAX_LISTENPORTS 4
+
+/**
+ * uIP buffer size.
+ *
+ * \hideinitializer
+ */
+
+ #define UIP_CONF_BUFFER_SIZE 98
+//#define UIP_CONF_BUFFER_SIZE 118
+
+/**
+ * The TCP maximum segment size.
+ *
+ * This is should not be to set to more than
+ * UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN.
+ */
+ #define UIP_CONF_TCP_MSS 512
+
+/**
+ * The size of the advertised receiver's window.
+ *
+ * Should be set low (i.e., to the size of the uip_buf buffer) is the
+ * application is slow to process incoming data, or high (32768 bytes)
+ * if the application processes data quickly.
+ *
+ * \hideinitializer
+ */
+
+ #define UIP_CONF_RECEIVE_WINDOW 512
+
+/**
+ * CPU byte order.
+ *
+ * \hideinitializer
+ */
+
+ #define UIP_CONF_BYTE_ORDER LITTLE_ENDIAN
+
+/**
+ * Logging on or off
+ *
+ * \hideinitializer
+ */
+
+ #define UIP_CONF_LOGGING 0
+
+/**
+ * UDP support on or off
+ * (see uipethernet-conf.h)
+ * \hideinitializer
+ *
+ * #define UIP_CONF_UDP 1
+ *
+ * #define UIP_CONF_UDP_CONNS 4
+ */
+
+/**
+ * UDP checksums on or off
+ *
+ * \hideinitializer
+ */
+ #define UIP_CONF_UDP_CHECKSUMS 1
+
+/**
+ * UDP Broadcast (receive) on or off
+ * (see uipethernet-conf.h)
+ * \hideinitializer
+ * #define UIP_CONF_BROADCAST 1
+ */
+
+/**
+ * uIP statistics on or off
+ *
+ * \hideinitializer
+ */
+ #define UIP_CONF_STATISTICS 0
+
+// SLIP
+
+//#define UIP_CONF_LLH_LEN 0
+typedef struct uipethernet_state
+{
+ void* user;
+} uip_tcp_appstate_t;
+
+void uipethernet_appcall(void);
+
+ #define UIP_APPCALL uipethernet_appcall
+
+typedef struct uipudp_state
+{
+ void* user;
+} uip_udp_appstate_t;
+
+void uipudp_appcall(void);
+
+ #define UIP_UDP_APPCALL uipudp_appcall
+
+ #define CC_REGISTER_ARG register
+
+ #define UIP_ARCH_CHKSUM 1
+#endif /* __UIP_CONF_H__ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/uip-neighbor.c Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2006, Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the Institute nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack
+ *
+ * $Id: uip-neighbor.c,v 1.2 2006/06/12 08:00:30 adam Exp $
+ */
+/**
+ * \file
+ * Database of link-local neighbors, used by IPv6 code and
+ * to be used by a future ARP code rewrite.
+ * \author
+ * Adam Dunkels <adam@sics.se>
+ */
+#include "uip-neighbor.h"
+
+#include <string.h>
+
+#define MAX_TIME 128
+
+#ifdef UIP_NEIGHBOR_CONF_ENTRIES
+ #define ENTRIES UIP_NEIGHBOR_CONF_ENTRIES
+#else /* UIP_NEIGHBOR_CONF_ENTRIES */
+
+ #define ENTRIES 8
+#endif /* UIP_NEIGHBOR_CONF_ENTRIES */
+
+struct neighbor_entry
+{
+ uip_ipaddr_t ipaddr;
+ struct uip_neighbor_addr addr;
+ u8_t time;
+};
+static struct neighbor_entry entries[ENTRIES];
+
+/*---------------------------------------------------------------------------*/
+void uip_neighbor_init(void) {
+ int i;
+
+ for(i = 0; i < ENTRIES; ++i) {
+ entries[i].time = MAX_TIME;
+ }
+}
+
+/*---------------------------------------------------------------------------*/
+void uip_neighbor_periodic(void) {
+ int i;
+
+ for(i = 0; i < ENTRIES; ++i) {
+ if(entries[i].time < MAX_TIME) {
+ entries[i].time++;
+ }
+ }
+}
+
+/*---------------------------------------------------------------------------*/
+void uip_neighbor_add(uip_ipaddr_t ipaddr, struct uip_neighbor_addr* addr) {
+ int i, oldest;
+ u8_t oldest_time;
+
+ printf
+ (
+ "Adding neighbor with link address %02x:%02x:%02x:%02x:%02x:%02x\n",
+ addr->addr.addr[0],
+ addr->addr.addr[1],
+ addr->addr.addr[2],
+ addr->addr.addr[3],
+ addr->addr.addr[4],
+ addr->addr.addr[5]
+ );
+
+ /* Find the first unused entry or the oldest used entry. */
+ oldest_time = 0;
+ oldest = 0;
+ for(i = 0; i < ENTRIES; ++i) {
+ if(entries[i].time == MAX_TIME) {
+ oldest = i;
+ break;
+ }
+
+ if(uip_ipaddr_cmp(entries[i].ipaddr, addr)) {
+ oldest = i;
+ break;
+ }
+
+ if(entries[i].time > oldest_time) {
+ oldest = i;
+ oldest_time = entries[i].time;
+ }
+ }
+
+ /* Use the oldest or first free entry (either pointed to by the
+ "oldest" variable). */
+ entries[oldest].time = 0;
+ uip_ipaddr_copy(entries[oldest].ipaddr, ipaddr);
+ memcpy(&entries[oldest].addr, addr, sizeof(struct uip_neighbor_addr));
+}
+
+/*---------------------------------------------------------------------------*/
+static struct neighbor_entry* find_entry(uip_ipaddr_t ipaddr) {
+ int i;
+
+ for(i = 0; i < ENTRIES; ++i) {
+ if(uip_ipaddr_cmp(entries[i].ipaddr, ipaddr)) {
+ return &entries[i];
+ }
+ }
+
+ return NULL;
+}
+
+/*---------------------------------------------------------------------------*/
+void uip_neighbor_update(uip_ipaddr_t ipaddr) {
+ struct neighbor_entry* e;
+
+ e = find_entry(ipaddr);
+ if(e != NULL) {
+ e->time = 0;
+ }
+}
+
+/*---------------------------------------------------------------------------*/
+struct uip_neighbor_addr* uip_neighbor_lookup(uip_ipaddr_t ipaddr) {
+ struct neighbor_entry* e;
+
+ e = find_entry(ipaddr);
+ if(e != NULL) {
+
+ /* printf("Lookup neighbor with link address %02x:%02x:%02x:%02x:%02x:%02x\n",
+ e->addr.addr.addr[0], e->addr.addr.addr[1], e->addr.addr.addr[2], e->addr.addr.addr[3],
+ e->addr.addr.addr[4], e->addr.addr.addr[5]);*/
+ return &e->addr;
+ }
+
+ return NULL;
+}
+
+/*---------------------------------------------------------------------------*/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/uip-neighbor.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2006, Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the Institute nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack
+ *
+ * $Id: uip-neighbor.h,v 1.2 2006/06/12 08:00:30 adam Exp $
+ */
+/**
+ * \file
+ * Header file for database of link-local neighbors, used by
+ * IPv6 code and to be used by future ARP code.
+ * \author
+ * Adam Dunkels <adam@sics.se>
+ */
+#ifndef __UIP_NEIGHBOR_H__
+ #define __UIP_NEIGHBOR_H__
+
+ #include "uip.h"
+
+struct uip_neighbor_addr
+{
+ #if UIP_NEIGHBOR_CONF_ADDRTYPE
+ UIP_NEIGHBOR_CONF_ADDRTYPE addr;
+ #else
+ struct uip_eth_addr addr;
+ #endif
+};
+
+void uip_neighbor_init(void);
+void uip_neighbor_add(uip_ipaddr_t ipaddr, struct uip_neighbor_addr* addr);
+void uip_neighbor_update(uip_ipaddr_t ipaddr);
+struct uip_neighbor_addr* uip_neighbor_lookup(uip_ipaddr_t ipaddr);
+void uip_neighbor_periodic(void);
+#endif /* __UIP-NEIGHBOR_H__ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/uip.c Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,2054 @@
+#define DEBUG_PRINTF(...) /*printf(__VA_ARGS__)*/
+
+/**
+ * \defgroup uip The uIP TCP/IP stack
+ * @{
+ *
+ * uIP is an implementation of the TCP/IP protocol stack intended for
+ * small 8-bit and 16-bit microcontrollers.
+ *
+ * uIP provides the necessary protocols for Internet communication,
+ * with a very small code footprint and RAM requirements - the uIP
+ * code size is on the order of a few kilobytes and RAM usage is on
+ * the order of a few hundred bytes.
+ */
+
+/**
+ * \file
+ * The uIP TCP/IP stack code.
+ * \author Adam Dunkels <adam@dunkels.com>
+ */
+/*
+ * Copyright (c) 2001-2003, Adam Dunkels.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack.
+ *
+ * $Id: uip.c,v 1.65 2006/06/11 21:46:39 adam Exp $
+ *
+ */
+/*
+ * uIP is a small implementation of the IP, UDP and TCP protocols (as
+ * well as some basic ICMP stuff). The implementation couples the IP,
+ * UDP, TCP and the application layers very tightly. To keep the size
+ * of the compiled code down, this code frequently uses the goto
+ * statement. While it would be possible to break the uip_process()
+ * function into many smaller functions, this would increase the code
+ * size because of the overhead of parameter passing and the fact that
+ * the optimier would not be as efficient.
+ *
+ * The principle is that we have a small buffer, called the uip_buf,
+ * in which the device driver puts an incoming packet. The TCP/IP
+ * stack parses the headers in the packet, and calls the
+ * application. If the remote host has sent data to the application,
+ * this data is present in the uip_buf and the application read the
+ * data from there. It is up to the application to put this data into
+ * a byte stream if needed. The application will not be fed with data
+ * that is out of sequence.
+ *
+ * If the application whishes to send data to the peer, it should put
+ * its data into the uip_buf. The uip_appdata pointer points to the
+ * first available byte. The TCP/IP stack will calculate the
+ * checksums, and fill in the necessary header fields and finally send
+ * the packet back to the peer.
+*/
+#include "uip.h"
+#include "uipopt.h"
+#include "uip_arch.h"
+
+#if UIP_CONF_IPV6
+ #include "uip-neighbor.h"
+#endif /* UIP_CONF_IPV6 */
+
+#include <string.h>
+
+/*---------------------------------------------------------------------------*/
+
+/* Variable definitions. */
+/* The IP address of this host. If it is defined to be fixed (by
+ setting UIP_FIXEDADDR to 1 in uipopt.h), the address is set
+ here. Otherwise, the address */
+#if UIP_FIXEDADDR > 0
+const uip_ipaddr_t uip_hostaddr = { HTONS((UIP_IPADDR0 << 8) | UIP_IPADDR1), HTONS
+ ((UIP_IPADDR2 << 8) | UIP_IPADDR3) };
+const uip_ipaddr_t uip_draddr =
+{
+ HTONS((UIP_DRIPADDR0 << 8) | UIP_DRIPADDR1),
+ HTONS((UIP_DRIPADDR2 << 8) | UIP_DRIPADDR3)
+};
+const uip_ipaddr_t uip_netmask =
+{
+ HTONS((UIP_NETMASK0 << 8) | UIP_NETMASK1),
+ HTONS((UIP_NETMASK2 << 8) | UIP_NETMASK3)
+};
+#else
+uip_ipaddr_t uip_hostaddr, uip_draddr, uip_netmask;
+#endif /* UIP_FIXEDADDR */
+
+static const uip_ipaddr_t all_ones_addr =
+#if UIP_CONF_IPV6
+{ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff };
+#else /* UIP_CONF_IPV6 */
+{
+ 0xffff, 0xffff
+};
+#endif /* UIP_CONF_IPV6 */
+static const uip_ipaddr_t all_zeroes_addr =
+#if UIP_CONF_IPV6
+{ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 };
+#else /* UIP_CONF_IPV6 */
+{
+ 0x0000, 0x0000
+};
+#endif /* UIP_CONF_IPV6 */
+
+#if UIP_FIXEDETHADDR
+const struct uip_eth_addr uip_ethaddr =
+{
+ { UIP_ETHADDR0, UIP_ETHADDR1, UIP_ETHADDR2, UIP_ETHADDR3, UIP_ETHADDR4, UIP_ETHADDR5 }
+};
+#else
+struct uip_eth_addr uip_ethaddr = { { 0, 0, 0, 0, 0, 0 } };
+#endif
+#ifndef UIP_CONF_EXTERNAL_BUFFER
+u8_t uip_buf[UIP_BUFSIZE + 2]; /* The packet buffer that contains
+ incoming packets. */
+#endif /* UIP_CONF_EXTERNAL_BUFFER */
+
+void* uip_appdata; /* The uip_appdata pointer points to
+ application data. */
+void* uip_sappdata; /* The uip_appdata pointer points to
+ the application data which is to
+ be sent. */
+#if UIP_URGDATA > 0
+void* uip_urgdata; /* The uip_urgdata pointer points to
+ urgent data (out-of-band data), if
+ present. */
+u16_t uip_urglen, uip_surglen;
+#endif /* UIP_URGDATA > 0 */
+
+u16_t uip_len, uip_slen;
+
+/* The uip_len is either 8 or 16 bits,
+ depending on the maximum packet
+ size. */
+u8_t uip_flags; /* The uip_flags variable is used for
+ communication between the TCP/IP stack
+ and the application program. */
+struct uip_conn* uip_conn; /* uip_conn always points to the current
+ connection. */
+
+struct uip_conn uip_conns[UIP_CONNS];
+
+/* The uip_conns array holds all TCP
+ connections. */
+u16_t uip_listenports[UIP_LISTENPORTS];
+
+/* The uip_listenports list all currently
+ listning ports. */
+#if UIP_UDP
+struct uip_udp_conn* uip_udp_conn;
+struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
+#endif /* UIP_UDP */
+
+static u16_t ipid; /* Ths ipid variable is an increasing
+ number that is used for the IP ID
+ field. */
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void uip_setipid(u16_t id) {
+ ipid = id;
+}
+
+static u8_t iss[4]; /* The iss variable is used for the TCP
+ initial sequence number. */
+
+#if UIP_ACTIVE_OPEN
+static u16_t lastport; /* Keeps track of the last port used for
+ a new connection. */
+#endif /* UIP_ACTIVE_OPEN */
+
+/* Temporary variables. */
+
+u8_t uip_acc32[4];
+static u8_t c, opt;
+static u16_t tmp16;
+
+/* Structures and definitions. */
+
+#define TCP_FIN 0x01
+#define TCP_SYN 0x02
+#define TCP_RST 0x04
+#define TCP_PSH 0x08
+#define TCP_ACK 0x10
+#define TCP_URG 0x20
+#define TCP_CTL 0x3f
+
+#define TCP_OPT_END 0 /* End of TCP options list */
+
+#define TCP_OPT_NOOP 1 /* "No-operation" TCP option */
+
+#define TCP_OPT_MSS 2 /* Maximum segment size TCP option */
+
+#define TCP_OPT_MSS_LEN 4 /* Length of TCP MSS option. */
+
+#define ICMP_ECHO_REPLY 0
+#define ICMP_ECHO 8
+
+#define ICMP6_ECHO_REPLY 129
+#define ICMP6_ECHO 128
+#define ICMP6_NEIGHBOR_SOLICITATION 135
+#define ICMP6_NEIGHBOR_ADVERTISEMENT 136
+
+#define ICMP6_FLAG_S (1 << 6)
+#define ICMP6_OPTION_SOURCE_LINK_ADDRESS 1
+#define ICMP6_OPTION_TARGET_LINK_ADDRESS 2
+
+/* Macros. */
+
+#define BUF ((struct uip_tcpip_hdr*) &uip_buf[UIP_LLH_LEN])
+#define FBUF ((struct uip_tcpip_hdr*) &uip_reassbuf[0])
+#define ICMPBUF ((struct uip_icmpip_hdr*) &uip_buf[UIP_LLH_LEN])
+#define UDPBUF ((struct uip_udpip_hdr*) &uip_buf[UIP_LLH_LEN])
+#if UIP_STATISTICS == 1
+struct uip_stats uip_stat;
+ #define UIP_STAT(s) s
+#else
+ #define UIP_STAT(s)
+#endif /* UIP_STATISTICS == 1 */
+
+#if UIP_LOGGING == 1
+ #include <stdio.h>
+void uip_log(char* msg);
+ #define UIP_LOG(m) uip_log(m)
+#else
+ #define UIP_LOG(m)
+#endif /* UIP_LOGGING == 1 */
+
+#if !UIP_ARCH_ADD32
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void uip_add32(u8_t* op32, u16_t op16) {
+ uip_acc32[3] = op32[3] + (op16 & 0xff);
+ uip_acc32[2] = op32[2] + (op16 >> 8);
+ uip_acc32[1] = op32[1];
+ uip_acc32[0] = op32[0];
+
+ if(uip_acc32[2] < (op16 >> 8)) {
+ ++uip_acc32[1];
+ if(uip_acc32[1] == 0) {
+ ++uip_acc32[0];
+ }
+ }
+
+ if(uip_acc32[3] < (op16 & 0xff)) {
+ ++uip_acc32[2];
+ if(uip_acc32[2] == 0) {
+ ++uip_acc32[1];
+ if(uip_acc32[1] == 0) {
+ ++uip_acc32[0];
+ }
+ }
+ }
+}
+#endif /* UIP_ARCH_ADD32 */
+
+#if !UIP_ARCH_CHKSUM
+
+/*---------------------------------------------------------------------------*/
+static u16_t chksum(u16_t sum, const u8_t* data, u16_t len) {
+ u16_t t;
+ const u8_t* dataptr;
+ const u8_t* last_byte;
+
+ dataptr = data;
+ last_byte = data + len - 1;
+
+ while(dataptr < last_byte) {
+
+ /* At least two more bytes */
+ t = (dataptr[0] << 8) + dataptr[1];
+ sum += t;
+ if(sum < t) {
+ sum++; /* carry */
+ }
+
+ dataptr += 2;
+ }
+
+ if(dataptr == last_byte) {
+ t = (dataptr[0] << 8) + 0;
+ sum += t;
+ if(sum < t) {
+ sum++; /* carry */
+ }
+ }
+
+ /* Return sum in host byte order. */
+ return sum;
+}
+
+/*---------------------------------------------------------------------------*/
+u16_t uip_chksum(u16_t* data, u16_t len) {
+ return htons(chksum(0, (u8_t*)data, len));
+}
+
+/*---------------------------------------------------------------------------*/
+ #ifndef UIP_ARCH_IPCHKSUM
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+u16_t uip_ipchksum(void) {
+ u16_t sum;
+
+ sum = chksum(0, &uip_buf[UIP_LLH_LEN], UIP_IPH_LEN);
+ DEBUG_PRINTF("uip_ipchksum: sum 0x%04x\n", sum);
+ return(sum == 0) ? 0xffff : htons(sum);
+}
+ #endif
+
+/*---------------------------------------------------------------------------*/
+static u16_t upper_layer_chksum(u8_t proto) {
+ u16_t upper_layer_len;
+ u16_t sum;
+
+ #if UIP_CONF_IPV6
+ upper_layer_len = (((u16_t) (BUF->len[0]) << 8) + BUF->len[1]);
+ #else /* UIP_CONF_IPV6 */
+ upper_layer_len = (((u16_t) (BUF->len[0]) << 8) + BUF->len[1]) - UIP_IPH_LEN;
+ #endif /* UIP_CONF_IPV6 */
+
+ /* First sum pseudoheader. */
+
+ /* IP protocol and length fields. This addition cannot carry. */
+ sum = upper_layer_len + proto;
+
+ /* Sum IP source and destination addresses. */
+ sum = chksum(sum, (u8_t*) &BUF->srcipaddr[0], 2 * sizeof(uip_ipaddr_t));
+
+ /* Sum TCP header and data. */
+ sum = chksum(sum, &uip_buf[UIP_IPH_LEN + UIP_LLH_LEN], upper_layer_len);
+
+ return(sum == 0) ? 0xffff : htons(sum);
+}
+
+/*---------------------------------------------------------------------------*/
+ #if UIP_CONF_IPV6
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+u16_t uip_icmp6chksum(void) {
+ return upper_layer_chksum(UIP_PROTO_ICMP6);
+}
+ #endif /* UIP_CONF_IPV6 */
+
+/*---------------------------------------------------------------------------*/
+u16_t uip_tcpchksum(void) {
+ return upper_layer_chksum(UIP_PROTO_TCP);
+}
+
+/*---------------------------------------------------------------------------*/
+ #if UIP_UDP_CHECKSUMS
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+u16_t uip_udpchksum(void) {
+ return upper_layer_chksum(UIP_PROTO_UDP);
+}
+ #endif /* UIP_UDP_CHECKSUMS */
+#endif /* UIP_ARCH_CHKSUM */
+
+/*---------------------------------------------------------------------------*/
+void uip_init(void) {
+ for(c = 0; c < UIP_LISTENPORTS; ++c) {
+ uip_listenports[c] = 0;
+ }
+
+ for(c = 0; c < UIP_CONNS; ++c) {
+ uip_conns[c].tcpstateflags = UIP_CLOSED;
+ }
+
+#if UIP_ACTIVE_OPEN
+ lastport = 1024;
+#endif /* UIP_ACTIVE_OPEN */
+
+#if UIP_UDP
+ for(c = 0; c < UIP_UDP_CONNS; ++c) {
+ uip_udp_conns[c].lport = 0;
+ }
+#endif /* UIP_UDP */
+
+ /* IPv4 initialization. */
+
+#if UIP_FIXEDADDR == 0
+ /* uip_hostaddr[0] = uip_hostaddr[1] = 0;*/
+#endif /* UIP_FIXEDADDR */
+}
+
+/*---------------------------------------------------------------------------*/
+#if UIP_ACTIVE_OPEN
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+struct uip_conn* uip_connect(uip_ipaddr_t* ripaddr, u16_t rport) {
+ register struct uip_conn* conn, *cconn;
+
+ /* Find an unused local port. */
+
+again:
+ ++lastport;
+
+ if(lastport >= 32000) {
+ lastport = 4096;
+ }
+
+ /* Check if this port is already in use, and if so try to find
+ another one. */
+ for(c = 0; c < UIP_CONNS; ++c) {
+ conn = &uip_conns[c];
+ if(conn->tcpstateflags != UIP_CLOSED && conn->lport == htons(lastport)) {
+ goto again;
+ }
+ }
+
+ conn = 0;
+ for(c = 0; c < UIP_CONNS; ++c) {
+ cconn = &uip_conns[c];
+ if(cconn->tcpstateflags == UIP_CLOSED) {
+ conn = cconn;
+ break;
+ }
+
+ if(cconn->tcpstateflags == UIP_TIME_WAIT) {
+ if(conn == 0 || cconn->timer > conn->timer) {
+ conn = cconn;
+ }
+ }
+ }
+
+ if(conn == 0) {
+ return 0;
+ }
+
+ conn->tcpstateflags = UIP_SYN_SENT;
+
+ conn->snd_nxt[0] = iss[0];
+ conn->snd_nxt[1] = iss[1];
+ conn->snd_nxt[2] = iss[2];
+ conn->snd_nxt[3] = iss[3];
+
+ conn->initialmss = conn->mss = UIP_TCP_MSS;
+
+ conn->len = 1; /* TCP length of the SYN is one. */
+ conn->nrtx = 0;
+ conn->timer = 1; /* Send the SYN next time around. */
+ conn->rto = UIP_RTO;
+ conn->sa = 0;
+ conn->sv = 16; /* Initial value of the RTT variance. */
+ conn->lport = htons(lastport);
+ conn->rport = rport;
+ uip_ipaddr_copy(&conn->ripaddr, ripaddr);
+
+ return conn;
+}
+#endif /* UIP_ACTIVE_OPEN */
+
+/*---------------------------------------------------------------------------*/
+
+#if UIP_UDP
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+struct uip_udp_conn* uip_udp_new(uip_ipaddr_t* ripaddr, u16_t rport) {
+ register struct uip_udp_conn* conn;
+
+ /* Find an unused local port. */
+
+again:
+ ++lastport;
+
+ if(lastport >= 32000) {
+ lastport = 4096;
+ }
+
+ for(c = 0; c < UIP_UDP_CONNS; ++c) {
+ if(uip_udp_conns[c].lport == htons(lastport)) {
+ goto again;
+ }
+ }
+
+ conn = 0;
+ for(c = 0; c < UIP_UDP_CONNS; ++c) {
+ if(uip_udp_conns[c].lport == 0) {
+ conn = &uip_udp_conns[c];
+ break;
+ }
+ }
+
+ if(conn == 0) {
+ return 0;
+ }
+
+ conn->lport = HTONS(lastport);
+ conn->rport = rport;
+ if(ripaddr == NULL) {
+ memset(conn->ripaddr, 0, sizeof(uip_ipaddr_t));
+ }
+ else {
+ uip_ipaddr_copy(&conn->ripaddr, ripaddr);
+ }
+
+ conn->ttl = UIP_TTL;
+
+ return conn;
+}
+#endif /* UIP_UDP */
+
+/*---------------------------------------------------------------------------*/
+void uip_unlisten(u16_t port) {
+ for(c = 0; c < UIP_LISTENPORTS; ++c) {
+ if(uip_listenports[c] == port) {
+ uip_listenports[c] = 0;
+ return;
+ }
+ }
+}
+
+/*---------------------------------------------------------------------------*/
+void uip_listen(u16_t port) {
+ for(c = 0; c < UIP_LISTENPORTS; ++c) {
+ if(uip_listenports[c] == 0) {
+ uip_listenports[c] = port;
+ return;
+ }
+ }
+}
+
+/*---------------------------------------------------------------------------*/
+/* XXX: IP fragment reassembly: not well-tested. */
+#if UIP_REASSEMBLY && !UIP_CONF_IPV6
+ #define UIP_REASS_BUFSIZE (UIP_BUFSIZE - UIP_LLH_LEN)
+static u8_t uip_reassbuf[UIP_REASS_BUFSIZE];
+static u8_t uip_reassbitmap[UIP_REASS_BUFSIZE / (8 * 8)];
+static const u8_t bitmap_bits[8] = { 0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01 };
+static u16_t uip_reasslen;
+static u8_t uip_reassflags;
+ #define UIP_REASS_FLAG_LASTFRAG 0x01
+static u8_t uip_reasstmr;
+
+ #define IP_MF 0x20
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+static u8_t uip_reass(void) {
+ u16_t offset, len;
+ u16_t i;
+
+ /* If ip_reasstmr is zero, no packet is present in the buffer, so we
+ write the IP header of the fragment into the reassembly
+ buffer. The timer is updated with the maximum age. */
+
+ if(uip_reasstmr == 0) {
+ memcpy(uip_reassbuf, &BUF->vhl, UIP_IPH_LEN);
+ uip_reasstmr = UIP_REASS_MAXAGE;
+ uip_reassflags = 0;
+
+ /* Clear the bitmap. */
+ memset(uip_reassbitmap, 0, sizeof(uip_reassbitmap));
+ }
+
+ /* Check if the incoming fragment matches the one currently present
+ in the reasembly buffer. If so, we proceed with copying the
+ fragment into the buffer. */
+ if
+ (
+ BUF->srcipaddr[0] == FBUF->srcipaddr[0]
+ && BUF->srcipaddr[1] == FBUF->srcipaddr[1]
+ && BUF->destipaddr[0] == FBUF->destipaddr[0]
+ && BUF->destipaddr[1] == FBUF->destipaddr[1]
+ && BUF->ipid[0] == FBUF->ipid[0]
+ && BUF->ipid[1] == FBUF->ipid[1]
+ ) {
+ len = (BUF->len[0] << 8) + BUF->len[1] - (BUF->vhl & 0x0f) * 4;
+ offset = (((BUF->ipoffset[0] & 0x3f) << 8) + BUF->ipoffset[1]) * 8;
+
+ /* If the offset or the offset + fragment length overflows the
+ reassembly buffer, we discard the entire packet. */
+ if(offset > UIP_REASS_BUFSIZE || offset + len > UIP_REASS_BUFSIZE) {
+ uip_reasstmr = 0;
+ goto nullreturn;
+ }
+
+ /* Copy the fragment into the reassembly buffer, at the right
+ offset. */
+ memcpy(&uip_reassbuf[UIP_IPH_LEN + offset], (char*)BUF + (int)((BUF->vhl & 0x0f) * 4), len);
+
+ /* Update the bitmap. */
+ if(offset / (8 * 8) == (offset + len) / (8 * 8)) {
+
+ /* If the two endpoints are in the same byte, we only update
+ that byte. */
+ uip_reassbitmap[offset / (8 * 8)] |= bitmap_bits[(offset / 8) & 7] &~bitmap_bits[((offset + len) / 8) & 7];
+ }
+ else {
+
+ /* If the two endpoints are in different bytes, we update the
+ bytes in the endpoints and fill the stuff inbetween with
+ 0xff. */
+ uip_reassbitmap[offset / (8 * 8)] |= bitmap_bits[(offset / 8) & 7];
+ for(i = 1 + offset / (8 * 8); i < (offset + len) / (8 * 8); ++i) {
+ uip_reassbitmap[i] = 0xff;
+ }
+
+ uip_reassbitmap[(offset + len) / (8 * 8)] |= ~bitmap_bits[((offset + len) / 8) & 7];
+ }
+
+ /* If this fragment has the More Fragments flag set to zero, we
+ know that this is the last fragment, so we can calculate the
+ size of the entire packet. We also set the
+ IP_REASS_FLAG_LASTFRAG flag to indicate that we have received
+ the final fragment. */
+ if((BUF->ipoffset[0] & IP_MF) == 0) {
+ uip_reassflags |= UIP_REASS_FLAG_LASTFRAG;
+ uip_reasslen = offset + len;
+ }
+
+ /* Finally, we check if we have a full packet in the buffer. We do
+ this by checking if we have the last fragment and if all bits
+ in the bitmap are set. */
+ if(uip_reassflags & UIP_REASS_FLAG_LASTFRAG) {
+
+ /* Check all bytes up to and including all but the last byte in
+ the bitmap. */
+ for(i = 0; i < uip_reasslen / (8 * 8) - 1; ++i) {
+ if(uip_reassbitmap[i] != 0xff) {
+ goto nullreturn;
+ }
+ }
+
+ /* Check the last byte in the bitmap. It should contain just the
+ right amount of bits. */
+ if(uip_reassbitmap[uip_reasslen / (8 * 8)] != (u8_t)~bitmap_bits[uip_reasslen / 8 & 7]) {
+ goto nullreturn;
+ }
+
+ /* If we have come this far, we have a full packet in the
+ buffer, so we allocate a pbuf and copy the packet into it. We
+ also reset the timer. */
+ uip_reasstmr = 0;
+ memcpy(BUF, FBUF, uip_reasslen);
+
+ /* Pretend to be a "normal" (i.e., not fragmented) IP packet
+ from now on. */
+ BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
+ BUF->len[0] = uip_reasslen >> 8;
+ BUF->len[1] = uip_reasslen & 0xff;
+ BUF->ipchksum = 0;
+ BUF->ipchksum = ~(uip_ipchksum());
+
+ return uip_reasslen;
+ }
+ }
+
+nullreturn:
+ return 0;
+}
+#endif /* UIP_REASSEMBLY */
+
+/*---------------------------------------------------------------------------*/
+static void uip_add_rcv_nxt(u16_t n) {
+ uip_add32(uip_conn->rcv_nxt, n);
+ uip_conn->rcv_nxt[0] = uip_acc32[0];
+ uip_conn->rcv_nxt[1] = uip_acc32[1];
+ uip_conn->rcv_nxt[2] = uip_acc32[2];
+ uip_conn->rcv_nxt[3] = uip_acc32[3];
+}
+
+/*---------------------------------------------------------------------------*/
+void uip_process(u8_t flag) {
+ register struct uip_conn* uip_connr = uip_conn;
+
+#if UIP_UDP
+ if(flag == UIP_UDP_SEND_CONN) {
+ goto udp_send;
+ }
+#endif /* UIP_UDP */
+
+ uip_sappdata = uip_appdata = &uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
+
+ /* Check if we were invoked because of a poll request for a
+ particular connection. */
+ if(flag == UIP_POLL_REQUEST) {
+ if((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED && !uip_outstanding(uip_connr)) {
+ uip_flags = UIP_POLL;
+ UIP_APPCALL();
+ goto appsend;
+ }
+
+ goto drop;
+
+ /* Check if we were invoked because of the perodic timer fireing. */
+ }
+ else
+ if(flag == UIP_TIMER)
+ {
+#if UIP_REASSEMBLY
+ if(uip_reasstmr != 0) {
+ --uip_reasstmr;
+ }
+#endif /* UIP_REASSEMBLY */
+
+ /* Increase the initial sequence number. */
+
+ if(++iss[3] == 0) {
+ if(++iss[2] == 0) {
+ if(++iss[1] == 0) {
+ ++iss[0];
+ }
+ }
+ }
+
+ /* Reset the length variables. */
+ uip_len = 0;
+ uip_slen = 0;
+
+ /* Check if the connection is in a state in which we simply wait
+ for the connection to time out. If so, we increase the
+ connection's timer and remove the connection if it times
+ out. */
+ if(uip_connr->tcpstateflags == UIP_TIME_WAIT || uip_connr->tcpstateflags == UIP_FIN_WAIT_2) {
+ ++(uip_connr->timer);
+ if(uip_connr->timer == UIP_TIME_WAIT_TIMEOUT) {
+ uip_connr->tcpstateflags = UIP_CLOSED;
+ }
+ }
+ else
+ if(uip_connr->tcpstateflags != UIP_CLOSED) {
+
+ /* If the connection has outstanding data, we increase the
+ connection's timer and see if it has reached the RTO value
+ in which case we retransmit. */
+ if(uip_outstanding(uip_connr)) {
+ if(uip_connr->timer-- == 0) {
+ if
+ (
+ uip_connr->nrtx == UIP_MAXRTX
+ || (
+ (uip_connr->tcpstateflags == UIP_SYN_SENT || uip_connr->tcpstateflags == UIP_SYN_RCVD)
+ && uip_connr->nrtx == UIP_MAXSYNRTX
+ )
+ ) {
+ uip_connr->tcpstateflags = UIP_CLOSED;
+
+ /* We call UIP_APPCALL() with uip_flags set to
+ UIP_TIMEDOUT to inform the application that the
+ connection has timed out. */
+ uip_flags = UIP_TIMEDOUT;
+ UIP_APPCALL();
+
+ /* We also send a reset packet to the remote host. */
+ BUF->flags = TCP_RST | TCP_ACK;
+ goto tcp_send_nodata;
+ }
+
+ /* Exponential backoff. */
+ uip_connr->timer = UIP_RTO << (uip_connr->nrtx > 4 ? 4 : uip_connr->nrtx);
+ ++(uip_connr->nrtx);
+
+ /* Ok, so we need to retransmit. We do this differently
+ depending on which state we are in. In ESTABLISHED, we
+ call upon the application so that it may prepare the
+ data for the retransmit. In SYN_RCVD, we resend the
+ SYNACK that we sent earlier and in LAST_ACK we have to
+ retransmit our FINACK. */
+ UIP_STAT(++uip_stat.tcp.rexmit);
+ switch(uip_connr->tcpstateflags & UIP_TS_MASK) {
+ case UIP_SYN_RCVD:
+ /* In the SYN_RCVD state, we should retransmit our
+ SYNACK. */
+ goto tcp_send_synack;
+
+#if UIP_ACTIVE_OPEN
+
+ case UIP_SYN_SENT:
+ /* In the SYN_SENT state, we retransmit out SYN. */
+ BUF->flags = 0;
+ goto tcp_send_syn;
+#endif /* UIP_ACTIVE_OPEN */
+
+ case UIP_ESTABLISHED:
+ /* In the ESTABLISHED state, we call upon the application
+ to do the actual retransmit after which we jump into
+ the code for sending out the packet (the apprexmit
+ label). */
+ uip_flags = UIP_REXMIT;
+ UIP_APPCALL();
+ goto apprexmit;
+
+ case UIP_FIN_WAIT_1:
+ case UIP_CLOSING:
+ case UIP_LAST_ACK:
+ /* In all these states we should retransmit a FINACK. */
+ goto tcp_send_finack;
+ }
+ }
+ }
+ else
+ if((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED) {
+
+ /* If there was no need for a retransmission, we poll the
+ application for new data. */
+ uip_flags = UIP_POLL;
+ UIP_APPCALL();
+ goto appsend;
+ }
+ }
+
+ goto drop;
+ }
+
+#if UIP_UDP
+ if(flag == UIP_UDP_TIMER) {
+ if(uip_udp_conn->lport != 0) {
+ uip_conn = NULL;
+ uip_sappdata = uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
+ uip_len = uip_slen = 0;
+ uip_flags = UIP_POLL;
+ UIP_UDP_APPCALL();
+ goto udp_send;
+ }
+ else {
+ goto drop;
+ }
+ }
+#endif
+ /* This is where the input processing starts. */
+
+ UIP_STAT(++uip_stat.ip.recv);
+
+ /* Start of IP input header processing code. */
+#if UIP_CONF_IPV6
+ /* Check validity of the IP header. */
+
+ if((BUF->vtc & 0xf0) != 0x60) {
+
+ /* IP version and header length. */
+ UIP_STAT(++uip_stat.ip.drop);
+ UIP_STAT(++uip_stat.ip.vhlerr);
+ UIP_LOG("ipv6: invalid version.");
+ goto drop;
+ }
+
+#else /* UIP_CONF_IPV6 */
+ /* Check validity of the IP header. */
+
+ if(BUF->vhl != 0x45) {
+
+ /* IP version and header length. */
+ UIP_STAT(++uip_stat.ip.drop);
+ UIP_STAT(++uip_stat.ip.vhlerr);
+ UIP_LOG("ip: invalid version or header length.");
+ goto drop;
+ }
+#endif /* UIP_CONF_IPV6 */
+
+ /* Check the size of the packet. If the size reported to us in
+ uip_len is smaller the size reported in the IP header, we assume
+ that the packet has been corrupted in transit. If the size of
+ uip_len is larger than the size reported in the IP packet header,
+ the packet has been padded and we set uip_len to the correct
+ value.. */
+
+ if((BUF->len[0] << 8) + BUF->len[1] <= uip_len) {
+ uip_len = (BUF->len[0] << 8) + BUF->len[1];
+#if UIP_CONF_IPV6
+ uip_len += 40; /* The length reported in the IPv6 header is the
+ length of the payload that follows the
+ header. However, uIP uses the uip_len variable
+ for holding the size of the entire packet,
+ including the IP header. For IPv4 this is not a
+ problem as the length field in the IPv4 header
+ contains the length of the entire packet. But
+ for IPv6 we need to add the size of the IPv6
+ header (40 bytes). */
+#endif /* UIP_CONF_IPV6 */
+ }
+ else {
+ UIP_LOG("ip: packet shorter than reported in IP header.");
+ goto drop;
+ }
+
+#if !UIP_CONF_IPV6
+ /* Check the fragment flag. */
+
+ if((BUF->ipoffset[0] & 0x3f) != 0 || BUF->ipoffset[1] != 0)
+ {
+ #if UIP_REASSEMBLY
+ uip_len = uip_reass();
+ if(uip_len == 0) {
+ goto drop;
+ }
+
+ #else /* UIP_REASSEMBLY */
+ UIP_STAT(++uip_stat.ip.drop);
+ UIP_STAT(++uip_stat.ip.fragerr);
+ UIP_LOG("ip: fragment dropped.");
+ goto drop;
+ #endif /* UIP_REASSEMBLY */
+ }
+#endif /* UIP_CONF_IPV6 */
+
+ if(uip_ipaddr_cmp(uip_hostaddr, all_zeroes_addr))
+ {
+ /* If we are configured to use ping IP address configuration and
+ hasn't been assigned an IP address yet, we accept all ICMP
+ packets. */
+#if UIP_PINGADDRCONF && !UIP_CONF_IPV6
+ if(BUF->proto == UIP_PROTO_ICMP) {
+ UIP_LOG("ip: possible ping config packet received.");
+ goto icmp_input;
+ }
+ else {
+ UIP_LOG("ip: packet dropped since no address assigned.");
+ goto drop;
+ }
+#endif /* UIP_PINGADDRCONF */
+ }
+ else
+ {
+ /* If IP broadcast support is configured, we check for a broadcast
+ UDP packet, which may be destined to us. */
+#if UIP_BROADCAST
+ DEBUG_PRINTF("UDP IP checksum 0x%04x\n", uip_ipchksum());
+ if
+ (
+ BUF->proto == UIP_PROTO_UDP
+ && uip_ipaddr_cmp(BUF->destipaddr, all_ones_addr) /*&&
+ uip_ipchksum() == 0xffff*/
+ ) {
+ goto udp_input;
+ }
+#endif /* UIP_BROADCAST */
+
+ /* Check if the packet is destined for our IP address. */
+
+#if !UIP_CONF_IPV6
+ if(!uip_ipaddr_cmp(BUF->destipaddr, uip_hostaddr)) {
+ UIP_STAT(++uip_stat.ip.drop);
+ goto drop;
+ }
+
+#else /* UIP_CONF_IPV6 */
+ /* For IPv6, packet reception is a little trickier as we need to
+ make sure that we listen to certain multicast addresses (all
+ hosts multicast address, and the solicited-node multicast
+ address) as well. However, we will cheat here and accept all
+ multicast packets that are sent to the ff02::/16 addresses. */
+
+ if(!uip_ipaddr_cmp(BUF->destipaddr, uip_hostaddr) && BUF->destipaddr[0] != HTONS(0xff02)) {
+ UIP_STAT(++uip_stat.ip.drop);
+ goto drop;
+ }
+#endif /* UIP_CONF_IPV6 */
+ }
+
+#if !UIP_CONF_IPV6
+ if(uip_ipchksum() != 0xffff) {
+
+ /* Compute and check the IP header
+ checksum. */
+ UIP_STAT(++uip_stat.ip.drop);
+ UIP_STAT(++uip_stat.ip.chkerr);
+ UIP_LOG("ip: bad checksum.");
+ goto drop;
+ }
+#endif /* UIP_CONF_IPV6 */
+
+ if(BUF->proto == UIP_PROTO_TCP) {
+
+ /* Check for TCP packet. If so,
+ proceed with TCP input
+ processing. */
+ goto tcp_input;
+ }
+
+#if UIP_UDP
+ if(BUF->proto == UIP_PROTO_UDP) {
+ goto udp_input;
+ }
+#endif /* UIP_UDP */
+
+#if !UIP_CONF_IPV6
+ /* ICMPv4 processing code follows. */
+
+ if(BUF->proto != UIP_PROTO_ICMP) {
+
+ /* We only allow ICMP packets from
+ here. */
+ UIP_STAT(++uip_stat.ip.drop);
+ UIP_STAT(++uip_stat.ip.protoerr);
+ UIP_LOG("ip: neither tcp nor icmp.");
+ goto drop;
+ }
+
+ #if UIP_PINGADDRCONF
+ icmp_input :
+ #endif /* UIP_PINGADDRCONF */
+
+ UIP_STAT(++uip_stat.icmp.recv);
+
+ /* ICMP echo (i.e., ping) processing. This is simple, we only change
+ the ICMP type from ECHO to ECHO_REPLY and adjust the ICMP
+ checksum before we return the packet. */
+ if(ICMPBUF->type != ICMP_ECHO) {
+ UIP_STAT(++uip_stat.icmp.drop);
+ UIP_STAT(++uip_stat.icmp.typeerr);
+ UIP_LOG("icmp: not icmp echo.");
+ goto drop;
+ }
+
+ /* If we are configured to use ping IP address assignment, we use
+ the destination IP address of this ping packet and assign it to
+ ourself. */
+ #if UIP_PINGADDRCONF
+ if((uip_hostaddr[0] | uip_hostaddr[1]) == 0) {
+ uip_hostaddr[0] = BUF->destipaddr[0];
+ uip_hostaddr[1] = BUF->destipaddr[1];
+ }
+ #endif /* UIP_PINGADDRCONF */
+
+ ICMPBUF->type = ICMP_ECHO_REPLY;
+
+ if(ICMPBUF->icmpchksum >= HTONS(0xffff - (ICMP_ECHO << 8))) {
+ ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8) + 1;
+ }
+ else {
+ ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8);
+ }
+
+ /* Swap IP addresses. */
+ uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr);
+ uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
+
+ UIP_STAT(++uip_stat.icmp.sent);
+ goto send;
+
+ /* End of IPv4 input header processing code. */
+#else /* !UIP_CONF_IPV6 */
+ /* This is IPv6 ICMPv6 processing code. */
+
+ DEBUG_PRINTF("icmp6_input: length %d\n", uip_len);
+
+ if(BUF->proto != UIP_PROTO_ICMP6) {
+
+ /* We only allow ICMPv6 packets from
+ here. */
+ UIP_STAT(++uip_stat.ip.drop);
+ UIP_STAT(++uip_stat.ip.protoerr);
+ UIP_LOG("ip: neither tcp nor icmp6.");
+ goto drop;
+ }
+
+ UIP_STAT(++uip_stat.icmp.recv);
+
+ /* If we get a neighbor solicitation for our address we should send
+ a neighbor advertisement message back. */
+ if(ICMPBUF->type == ICMP6_NEIGHBOR_SOLICITATION) {
+ if(uip_ipaddr_cmp(ICMPBUF->icmp6data, uip_hostaddr)) {
+ if(ICMPBUF->options[0] == ICMP6_OPTION_SOURCE_LINK_ADDRESS) {
+
+ /* Save the sender's address in our neighbor list. */
+ uip_neighbor_add(ICMPBUF->srcipaddr, &(ICMPBUF->options[2]));
+ }
+
+ /* We should now send a neighbor advertisement back to where the
+ neighbor solicication came from. */
+ ICMPBUF->type = ICMP6_NEIGHBOR_ADVERTISEMENT;
+ ICMPBUF->flags = ICMP6_FLAG_S; /* Solicited flag. */
+
+ ICMPBUF->reserved1 = ICMPBUF->reserved2 = ICMPBUF->reserved3 = 0;
+
+ uip_ipaddr_copy(ICMPBUF->destipaddr, ICMPBUF->srcipaddr);
+ uip_ipaddr_copy(ICMPBUF->srcipaddr, uip_hostaddr);
+ ICMPBUF->options[0] = ICMP6_OPTION_TARGET_LINK_ADDRESS;
+ ICMPBUF->options[1] = 1; /* Options length, 1 = 8 bytes. */
+ memcpy(&(ICMPBUF->options[2]), &uip_ethaddr, sizeof(uip_ethaddr));
+ ICMPBUF->icmpchksum = 0;
+ ICMPBUF->icmpchksum = ~uip_icmp6chksum();
+ goto send;
+ }
+
+ goto drop;
+ }
+ else
+ if(ICMPBUF->type == ICMP6_ECHO) {
+
+ /* ICMP echo (i.e., ping) processing. This is simple, we only
+ change the ICMP type from ECHO to ECHO_REPLY and update the
+ ICMP checksum before we return the packet. */
+ ICMPBUF->type = ICMP6_ECHO_REPLY;
+
+ uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr);
+ uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
+ ICMPBUF->icmpchksum = 0;
+ ICMPBUF->icmpchksum = ~uip_icmp6chksum();
+
+ UIP_STAT(++uip_stat.icmp.sent);
+ goto send;
+ }
+ else {
+ DEBUG_PRINTF("Unknown icmp6 message type %d\n", ICMPBUF->type);
+ UIP_STAT(++uip_stat.icmp.drop);
+ UIP_STAT(++uip_stat.icmp.typeerr);
+ UIP_LOG("icmp: unknown ICMP message.");
+ goto drop;
+ }
+
+ /* End of IPv6 ICMP processing. */
+#endif /* !UIP_CONF_IPV6 */
+
+#if UIP_UDP
+ /* UDP input processing. */
+
+ udp_input :
+ /* UDP processing is really just a hack. We don't do anything to the
+ UDP/IP headers, but let the UDP application do all the hard
+ work. If the application sets uip_slen, it has a packet to
+ send. */
+ #if UIP_UDP_CHECKSUMS
+ uip_len = uip_len - UIP_IPUDPH_LEN;
+ uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
+ if(UDPBUF->udpchksum != 0 && uip_udpchksum() != 0xffff) {
+ UIP_STAT(++uip_stat.udp.drop);
+ UIP_STAT(++uip_stat.udp.chkerr);
+ UIP_LOG("udp: bad checksum.");
+ goto drop;
+ }
+
+ #else /* UIP_UDP_CHECKSUMS */
+ uip_len = uip_len - UIP_IPUDPH_LEN;
+ #endif /* UIP_UDP_CHECKSUMS */
+
+ /* Demultiplex this UDP packet between the UDP "connections". */
+
+ for(uip_udp_conn = &uip_udp_conns[0]; uip_udp_conn < &uip_udp_conns[UIP_UDP_CONNS]; ++uip_udp_conn) {
+
+ /* If the local UDP port is non-zero, the connection is considered
+ to be used. If so, the local port number is checked against the
+ destination port number in the received packet. If the two port
+ numbers match, the remote port number is checked if the
+ connection is bound to a remote port. Finally, if the
+ connection is bound to a remote IP address, the source IP
+ address of the packet is checked. */
+ if
+ (
+ uip_udp_conn->lport != 0
+ && UDPBUF->destport == uip_udp_conn->lport
+ && (uip_udp_conn->rport == 0 || UDPBUF->srcport == uip_udp_conn->rport)
+ && (
+ uip_ipaddr_cmp(uip_udp_conn->ripaddr, all_zeroes_addr)
+ || uip_ipaddr_cmp(uip_udp_conn->ripaddr, all_ones_addr)
+ || uip_ipaddr_cmp(BUF->srcipaddr, uip_udp_conn->ripaddr)
+ )
+ ) {
+ goto udp_found;
+ }
+ }
+
+ UIP_LOG("udp: no matching connection found");
+ goto drop;
+
+udp_found:
+ uip_conn = NULL;
+ uip_flags = UIP_NEWDATA;
+ uip_sappdata = uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
+ uip_slen = 0;
+ UIP_UDP_APPCALL();
+udp_send:
+ if(uip_slen == 0) {
+ goto drop;
+ }
+
+ uip_len = uip_slen + UIP_IPUDPH_LEN;
+
+ #if UIP_CONF_IPV6
+ /* For IPv6, the IP length field does not include the IPv6 IP header
+ length. */
+
+ BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);
+ BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);
+ #else /* UIP_CONF_IPV6 */
+ BUF->len[0] = (uip_len >> 8);
+ BUF->len[1] = (uip_len & 0xff);
+ #endif /* UIP_CONF_IPV6 */
+
+ BUF->ttl = uip_udp_conn->ttl;
+ BUF->proto = UIP_PROTO_UDP;
+
+ UDPBUF->udplen = HTONS(uip_slen + UIP_UDPH_LEN);
+ UDPBUF->udpchksum = 0;
+
+ BUF->srcport = uip_udp_conn->lport;
+ BUF->destport = uip_udp_conn->rport;
+
+ uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
+ uip_ipaddr_copy(BUF->destipaddr, uip_udp_conn->ripaddr);
+
+ uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPTCPH_LEN];
+
+ #if UIP_UDP_CHECKSUMS
+ /* Calculate UDP checksum. */
+
+ UDPBUF->udpchksum = ~(uip_udpchksum());
+ if(UDPBUF->udpchksum == 0) {
+ UDPBUF->udpchksum = 0xffff;
+ }
+ #endif /* UIP_UDP_CHECKSUMS */
+
+ goto ip_send_nolen;
+#endif /* UIP_UDP */
+
+ /* TCP input processing. */
+
+ tcp_input : UIP_STAT(++uip_stat.tcp.recv);
+
+ /* Start of TCP input header processing code. */
+ if(uip_tcpchksum() != 0xffff) {
+
+ /* Compute and check the TCP
+ checksum. */
+ UIP_STAT(++uip_stat.tcp.drop);
+ UIP_STAT(++uip_stat.tcp.chkerr);
+ UIP_LOG("tcp: bad checksum.");
+ goto drop;
+ }
+
+ /* Demultiplex this segment. */
+ /* First check any active connections. */
+ for(uip_connr = &uip_conns[0]; uip_connr <= &uip_conns[UIP_CONNS - 1]; ++uip_connr) {
+ if
+ (
+ uip_connr->tcpstateflags != UIP_CLOSED
+ && BUF->destport == uip_connr->lport
+ && BUF->srcport == uip_connr->rport
+ && uip_ipaddr_cmp(BUF->srcipaddr, uip_connr->ripaddr)
+ ) {
+ goto found;
+ }
+ }
+
+ /* If we didn't find and active connection that expected the packet,
+ either this packet is an old duplicate, or this is a SYN packet
+ destined for a connection in LISTEN. If the SYN flag isn't set,
+ it is an old packet and we send a RST. */
+ if((BUF->flags & TCP_CTL) != TCP_SYN) {
+ goto reset;
+ }
+
+ tmp16 = BUF->destport;
+
+ /* Next, check listening connections. */
+ for(c = 0; c < UIP_LISTENPORTS; ++c) {
+ if(tmp16 == uip_listenports[c])
+ goto found_listen;
+ }
+
+ /* No matching connection found, so we send a RST packet. */
+ UIP_STAT(++uip_stat.tcp.synrst);
+reset:
+ /* We do not send resets in response to resets. */
+ if(BUF->flags & TCP_RST) {
+ goto drop;
+ }
+
+ UIP_STAT(++uip_stat.tcp.rst);
+
+ BUF->flags = TCP_RST | TCP_ACK;
+ uip_len = UIP_IPTCPH_LEN;
+ BUF->tcpoffset = 5 << 4;
+
+ /* Flip the seqno and ackno fields in the TCP header. */
+ c = BUF->seqno[3];
+ BUF->seqno[3] = BUF->ackno[3];
+ BUF->ackno[3] = c;
+
+ c = BUF->seqno[2];
+ BUF->seqno[2] = BUF->ackno[2];
+ BUF->ackno[2] = c;
+
+ c = BUF->seqno[1];
+ BUF->seqno[1] = BUF->ackno[1];
+ BUF->ackno[1] = c;
+
+ c = BUF->seqno[0];
+ BUF->seqno[0] = BUF->ackno[0];
+ BUF->ackno[0] = c;
+
+ /* We also have to increase the sequence number we are
+ acknowledging. If the least significant byte overflowed, we need
+ to propagate the carry to the other bytes as well. */
+ if(++BUF->ackno[3] == 0) {
+ if(++BUF->ackno[2] == 0) {
+ if(++BUF->ackno[1] == 0) {
+ ++BUF->ackno[0];
+ }
+ }
+ }
+
+ /* Swap port numbers. */
+ tmp16 = BUF->srcport;
+ BUF->srcport = BUF->destport;
+ BUF->destport = tmp16;
+
+ /* Swap IP addresses. */
+ uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr);
+ uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
+
+ /* And send out the RST packet! */
+ goto tcp_send_noconn;
+
+ /* This label will be jumped to if we matched the incoming packet
+ with a connection in LISTEN. In that case, we should create a new
+ connection and send a SYNACK in return. */
+found_listen:
+ /* First we check if there are any connections avaliable. Unused
+ connections are kept in the same table as used connections, but
+ unused ones have the tcpstate set to CLOSED. Also, connections in
+ TIME_WAIT are kept track of and we'll use the oldest one if no
+ CLOSED connections are found. Thanks to Eddie C. Dost for a very
+ nice algorithm for the TIME_WAIT search. */
+ uip_connr = 0;
+ for(c = 0; c < UIP_CONNS; ++c) {
+ if(uip_conns[c].tcpstateflags == UIP_CLOSED) {
+ uip_connr = &uip_conns[c];
+ break;
+ }
+
+ if(uip_conns[c].tcpstateflags == UIP_TIME_WAIT) {
+ if(uip_connr == 0 || uip_conns[c].timer > uip_connr->timer) {
+ uip_connr = &uip_conns[c];
+ }
+ }
+ }
+
+ if(uip_connr == 0) {
+
+ /* All connections are used already, we drop packet and hope that
+ the remote end will retransmit the packet at a time when we
+ have more spare connections. */
+ UIP_STAT(++uip_stat.tcp.syndrop);
+ UIP_LOG("tcp: found no unused connections.");
+ goto drop;
+ }
+
+ uip_conn = uip_connr;
+
+ /* Fill in the necessary fields for the new connection. */
+ uip_connr->rto = uip_connr->timer = UIP_RTO;
+ uip_connr->sa = 0;
+ uip_connr->sv = 4;
+ uip_connr->nrtx = 0;
+ uip_connr->lport = BUF->destport;
+ uip_connr->rport = BUF->srcport;
+ uip_ipaddr_copy(uip_connr->ripaddr, BUF->srcipaddr);
+ uip_connr->tcpstateflags = UIP_SYN_RCVD;
+
+ uip_connr->snd_nxt[0] = iss[0];
+ uip_connr->snd_nxt[1] = iss[1];
+ uip_connr->snd_nxt[2] = iss[2];
+ uip_connr->snd_nxt[3] = iss[3];
+ uip_connr->len = 1;
+
+ /* rcv_nxt should be the seqno from the incoming packet + 1. */
+ uip_connr->rcv_nxt[3] = BUF->seqno[3];
+ uip_connr->rcv_nxt[2] = BUF->seqno[2];
+ uip_connr->rcv_nxt[1] = BUF->seqno[1];
+ uip_connr->rcv_nxt[0] = BUF->seqno[0];
+ uip_add_rcv_nxt(1);
+
+ /* Parse the TCP MSS option, if present. */
+ if((BUF->tcpoffset & 0xf0) > 0x50) {
+ for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2;) {
+ opt = uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + c];
+ if(opt == TCP_OPT_END) {
+
+ /* End of options. */
+ break;
+ }
+ else
+ if(opt == TCP_OPT_NOOP) {
+ ++c;
+
+ /* NOP option. */
+ }
+ else
+ if(opt == TCP_OPT_MSS && uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == TCP_OPT_MSS_LEN) {
+
+ /* An MSS option with the right option length. */
+ tmp16 = ((u16_t) uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) | (u16_t) uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + 3 + c];
+ uip_connr->initialmss = uip_connr->mss = tmp16 > UIP_TCP_MSS ? UIP_TCP_MSS : tmp16;
+
+ /* And we are done processing options. */
+ break;
+ }
+ else {
+
+ /* All other options have a length field, so that we easily
+ can skip past them. */
+ if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {
+
+ /* If the length field is zero, the options are malformed
+ and we don't process them further. */
+ break;
+ }
+
+ c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
+ }
+ }
+ }
+
+ /* Our response will be a SYNACK. */
+#if UIP_ACTIVE_OPEN
+ tcp_send_synack : BUF->flags = TCP_ACK;
+
+tcp_send_syn:
+ BUF->flags |= TCP_SYN;
+#else /* UIP_ACTIVE_OPEN */
+ tcp_send_synack : BUF->flags = TCP_SYN | TCP_ACK;
+#endif /* UIP_ACTIVE_OPEN */
+
+ /* We send out the TCP Maximum Segment Size option with our
+ SYNACK. */
+
+ BUF->optdata[0] = TCP_OPT_MSS;
+ BUF->optdata[1] = TCP_OPT_MSS_LEN;
+ BUF->optdata[2] = (UIP_TCP_MSS) / 256;
+ BUF->optdata[3] = (UIP_TCP_MSS) & 255;
+ uip_len = UIP_IPTCPH_LEN + TCP_OPT_MSS_LEN;
+ BUF->tcpoffset = ((UIP_TCPH_LEN + TCP_OPT_MSS_LEN) / 4) << 4;
+ goto tcp_send;
+
+ /* This label will be jumped to if we found an active connection. */
+found:
+ uip_conn = uip_connr;
+ uip_flags = 0;
+
+ /* We do a very naive form of TCP reset processing; we just accept
+ any RST and kill our connection. We should in fact check if the
+ sequence number of this reset is wihtin our advertised window
+ before we accept the reset. */
+ if(BUF->flags & TCP_RST) {
+ uip_connr->tcpstateflags = UIP_CLOSED;
+ UIP_LOG("tcp: got reset, aborting connection.");
+ uip_flags = UIP_ABORT;
+ UIP_APPCALL();
+ goto drop;
+ }
+
+ /* Calculated the length of the data, if the application has sent
+ any data to us. */
+ c = (BUF->tcpoffset >> 4) << 2;
+
+ /* uip_len will contain the length of the actual TCP data. This is
+ calculated by subtracing the length of the TCP header (in
+ c) and the length of the IP header (20 bytes). */
+ uip_len = uip_len - c - UIP_IPH_LEN;
+
+ /* First, check if the sequence number of the incoming packet is
+ what we're expecting next. If not, we send out an ACK with the
+ correct numbers in. */
+ if(!(((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_SYN_SENT) && ((BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)))) {
+ if
+ (
+ (uip_len > 0 || ((BUF->flags & (TCP_SYN | TCP_FIN)) != 0))
+ && (
+ BUF->seqno[0] != uip_connr->rcv_nxt[0]
+ || BUF->seqno[1] != uip_connr->rcv_nxt[1]
+ || BUF->seqno[2] != uip_connr->rcv_nxt[2]
+ || BUF->seqno[3] != uip_connr->rcv_nxt[3]
+ )
+ ) {
+ goto tcp_send_ack;
+ }
+ }
+
+ /* Next, check if the incoming segment acknowledges any outstanding
+ data. If so, we update the sequence number, reset the length of
+ the outstanding data, calculate RTT estimations, and reset the
+ retransmission timer. */
+ if((BUF->flags & TCP_ACK) && uip_outstanding(uip_connr)) {
+ uip_add32(uip_connr->snd_nxt, uip_connr->len);
+
+ if
+ (
+ BUF->ackno[0] == uip_acc32[0]
+ && BUF->ackno[1] == uip_acc32[1]
+ && BUF->ackno[2] == uip_acc32[2]
+ && BUF->ackno[3] == uip_acc32[3]
+ ) {
+
+ /* Update sequence number. */
+ uip_connr->snd_nxt[0] = uip_acc32[0];
+ uip_connr->snd_nxt[1] = uip_acc32[1];
+ uip_connr->snd_nxt[2] = uip_acc32[2];
+ uip_connr->snd_nxt[3] = uip_acc32[3];
+
+ /* Do RTT estimation, unless we have done retransmissions. */
+ if(uip_connr->nrtx == 0) {
+ signed char m;
+ m = uip_connr->rto - uip_connr->timer;
+
+ /* This is taken directly from VJs original code in his paper */
+ m = m - (uip_connr->sa >> 3);
+ uip_connr->sa += m;
+ if(m < 0) {
+ m = -m;
+ }
+
+ m = m - (uip_connr->sv >> 2);
+ uip_connr->sv += m;
+ uip_connr->rto = (uip_connr->sa >> 3) + uip_connr->sv;
+ }
+
+ /* Set the acknowledged flag. */
+ uip_flags = UIP_ACKDATA;
+
+ /* Reset the retransmission timer. */
+ uip_connr->timer = uip_connr->rto;
+
+ /* Reset length of outstanding data. */
+ uip_connr->len = 0;
+ }
+ }
+
+ /* Do different things depending on in what state the connection is. */
+ switch(uip_connr->tcpstateflags & UIP_TS_MASK) {
+ /* CLOSED and LISTEN are not handled here. CLOSE_WAIT is not
+ implemented, since we force the application to close when the
+ peer sends a FIN (hence the application goes directly from
+ ESTABLISHED to LAST_ACK). */
+ case UIP_SYN_RCVD:
+ /* In SYN_RCVD we have sent out a SYNACK in response to a SYN, and
+ we are waiting for an ACK that acknowledges the data we sent
+ out the last time. Therefore, we want to have the UIP_ACKDATA
+ flag set. If so, we enter the ESTABLISHED state. */
+ if(uip_flags & UIP_ACKDATA) {
+ uip_connr->tcpstateflags = UIP_ESTABLISHED;
+ uip_flags = UIP_CONNECTED;
+ uip_connr->len = 0;
+ if(uip_len > 0) {
+ uip_flags |= UIP_NEWDATA;
+ uip_add_rcv_nxt(uip_len);
+ }
+
+ uip_slen = 0;
+ UIP_APPCALL();
+ goto appsend;
+ }
+
+ goto drop;
+#if UIP_ACTIVE_OPEN
+
+ case UIP_SYN_SENT:
+ /* In SYN_SENT, we wait for a SYNACK that is sent in response to
+ our SYN. The rcv_nxt is set to sequence number in the SYNACK
+ plus one, and we send an ACK. We move into the ESTABLISHED
+ state. */
+ if((uip_flags & UIP_ACKDATA) && (BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)) {
+
+ /* Parse the TCP MSS option, if present. */
+ if((BUF->tcpoffset & 0xf0) > 0x50) {
+ for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2;) {
+ opt = uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + c];
+ if(opt == TCP_OPT_END) {
+
+ /* End of options. */
+ break;
+ }
+ else
+ if(opt == TCP_OPT_NOOP) {
+ ++c;
+
+ /* NOP option. */
+ }
+ else
+ if(opt == TCP_OPT_MSS && uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == TCP_OPT_MSS_LEN) {
+
+ /* An MSS option with the right option length. */
+ tmp16 = (uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) | uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 3 + c];
+ uip_connr->initialmss = uip_connr->mss = tmp16 > UIP_TCP_MSS ? UIP_TCP_MSS : tmp16;
+
+ /* And we are done processing options. */
+ break;
+ }
+ else {
+
+ /* All other options have a length field, so that we easily
+ can skip past them. */
+ if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {
+
+ /* If the length field is zero, the options are malformed
+ and we don't process them further. */
+ break;
+ }
+
+ c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
+ }
+ }
+ }
+
+ uip_connr->tcpstateflags = UIP_ESTABLISHED;
+ uip_connr->rcv_nxt[0] = BUF->seqno[0];
+ uip_connr->rcv_nxt[1] = BUF->seqno[1];
+ uip_connr->rcv_nxt[2] = BUF->seqno[2];
+ uip_connr->rcv_nxt[3] = BUF->seqno[3];
+ uip_add_rcv_nxt(1);
+ uip_flags = UIP_CONNECTED | UIP_NEWDATA;
+ uip_connr->len = 0;
+ uip_len = 0;
+ uip_slen = 0;
+ UIP_APPCALL();
+ goto appsend;
+ }
+
+ /* Inform the application that the connection failed */
+ uip_flags = UIP_ABORT;
+ UIP_APPCALL();
+
+ /* The connection is closed after we send the RST */
+ uip_conn->tcpstateflags = UIP_CLOSED;
+ goto reset;
+#endif /* UIP_ACTIVE_OPEN */
+
+ case UIP_ESTABLISHED:
+ /* In the ESTABLISHED state, we call upon the application to feed
+ data into the uip_buf. If the UIP_ACKDATA flag is set, the
+ application should put new data into the buffer, otherwise we are
+ retransmitting an old segment, and the application should put that
+ data into the buffer.
+
+ If the incoming packet is a FIN, we should close the connection on
+ this side as well, and we send out a FIN and enter the LAST_ACK
+ state. We require that there is no outstanding data; otherwise the
+ sequence numbers will be screwed up. */
+ if(BUF->flags & TCP_FIN && !(uip_connr->tcpstateflags & UIP_STOPPED)) {
+ if(uip_outstanding(uip_connr)) {
+ goto drop;
+ }
+
+ uip_add_rcv_nxt(1 + uip_len);
+ uip_flags |= UIP_CLOSE;
+ if(uip_len > 0) {
+ uip_flags |= UIP_NEWDATA;
+ }
+
+ UIP_APPCALL();
+ uip_connr->len = 1;
+ uip_connr->tcpstateflags = UIP_LAST_ACK;
+ uip_connr->nrtx = 0;
+tcp_send_finack:
+ BUF->flags = TCP_FIN | TCP_ACK;
+ goto tcp_send_nodata;
+ }
+
+ /* Check the URG flag. If this is set, the segment carries urgent
+ data that we must pass to the application. */
+ if((BUF->flags & TCP_URG) != 0)
+ {
+#if UIP_URGDATA > 0
+ uip_urglen = (BUF->urgp[0] << 8) | BUF->urgp[1];
+ if(uip_urglen > uip_len) {
+
+ /* There is more urgent data in the next segment to come. */
+ uip_urglen = uip_len;
+ }
+
+ uip_add_rcv_nxt(uip_urglen);
+ uip_len -= uip_urglen;
+ uip_urgdata = uip_appdata;
+ uip_appdata += uip_urglen;
+ }
+ else {
+ uip_urglen = 0;
+#else /* UIP_URGDATA > 0 */
+ uip_appdata = ((char*)uip_appdata) + ((BUF->urgp[0] << 8) | BUF->urgp[1]);
+ uip_len -= (BUF->urgp[0] << 8) | BUF->urgp[1];
+#endif /* UIP_URGDATA > 0 */
+ }
+
+ /* If uip_len > 0 we have TCP data in the packet, and we flag this
+ by setting the UIP_NEWDATA flag and update the sequence number
+ we acknowledge. If the application has stopped the dataflow
+ using uip_stop(), we must not accept any data packets from the
+ remote host. */
+ if(uip_len > 0 && !(uip_connr->tcpstateflags & UIP_STOPPED)) {
+ uip_flags |= UIP_NEWDATA;
+ uip_add_rcv_nxt(uip_len);
+ }
+
+ /* Check if the available buffer space advertised by the other end
+ is smaller than the initial MSS for this connection. If so, we
+ set the current MSS to the window size to ensure that the
+ application does not send more data than the other end can
+ handle.
+
+ If the remote host advertises a zero window, we set the MSS to
+ the initial MSS so that the application will send an entire MSS
+ of data. This data will not be acknowledged by the receiver,
+ and the application will retransmit it. This is called the
+ "persistent timer" and uses the retransmission mechanim.
+ */
+ tmp16 = ((u16_t) BUF->wnd[0] << 8) + (u16_t) BUF->wnd[1];
+ if(tmp16 > uip_connr->initialmss || tmp16 == 0) {
+ tmp16 = uip_connr->initialmss;
+ }
+
+ uip_connr->mss = tmp16;
+
+ /* If this packet constitutes an ACK for outstanding data (flagged
+ by the UIP_ACKDATA flag, we should call the application since it
+ might want to send more data. If the incoming packet had data
+ from the peer (as flagged by the UIP_NEWDATA flag), the
+ application must also be notified.
+
+ When the application is called, the global variable uip_len
+ contains the length of the incoming data. The application can
+ access the incoming data through the global pointer
+ uip_appdata, which usually points UIP_IPTCPH_LEN + UIP_LLH_LEN
+ bytes into the uip_buf array.
+
+ If the application wishes to send any data, this data should be
+ put into the uip_appdata and the length of the data should be
+ put into uip_len. If the application don't have any data to
+ send, uip_len must be set to 0. */
+ if(uip_flags & (UIP_NEWDATA | UIP_ACKDATA)) {
+ uip_slen = 0;
+ UIP_APPCALL();
+
+appsend:
+ if(uip_flags & UIP_ABORT) {
+ uip_slen = 0;
+ uip_connr->tcpstateflags = UIP_CLOSED;
+ BUF->flags = TCP_RST | TCP_ACK;
+ goto tcp_send_nodata;
+ }
+
+ if(uip_flags & UIP_CLOSE) {
+ uip_slen = 0;
+ uip_connr->len = 1;
+ uip_connr->tcpstateflags = UIP_FIN_WAIT_1;
+ uip_connr->nrtx = 0;
+ BUF->flags = TCP_FIN | TCP_ACK;
+ goto tcp_send_nodata;
+ }
+
+ /* If uip_slen > 0, the application has data to be sent. */
+ if(uip_slen > 0) {
+
+ /* If the connection has acknowledged data, the contents of
+ the ->len variable should be discarded. */
+ if((uip_flags & UIP_ACKDATA) != 0) {
+ uip_connr->len = 0;
+ }
+
+ /* If the ->len variable is non-zero the connection has
+ already data in transit and cannot send anymore right
+ now. */
+ if(uip_connr->len == 0) {
+
+ /* The application cannot send more than what is allowed by
+ the mss (the minumum of the MSS and the available
+ window). */
+ if(uip_slen > uip_connr->mss) {
+ uip_slen = uip_connr->mss;
+ }
+
+ /* Remember how much data we send out now so that we know
+ when everything has been acknowledged. */
+ uip_connr->len = uip_slen;
+ }
+ else {
+
+ /* If the application already had unacknowledged data, we
+ make sure that the application does not send (i.e.,
+ retransmit) out more than it previously sent out. */
+ uip_slen = uip_connr->len;
+ }
+ }
+
+ uip_connr->nrtx = 0;
+apprexmit:
+ uip_appdata = uip_sappdata;
+
+ /* If the application has data to be sent, or if the incoming
+ packet had new data in it, we must send out a packet. */
+ if(uip_slen > 0 && uip_connr->len > 0) {
+
+ /* Add the length of the IP and TCP headers. */
+ uip_len = uip_connr->len + UIP_TCPIP_HLEN;
+
+ /* We always set the ACK flag in response packets. */
+ BUF->flags = TCP_ACK | TCP_PSH;
+
+ /* Send the packet. */
+ goto tcp_send_noopts;
+ }
+
+ /* If there is no data to send, just send out a pure ACK if
+ there is newdata. */
+ if(uip_flags & UIP_NEWDATA) {
+ uip_len = UIP_TCPIP_HLEN;
+ BUF->flags = TCP_ACK;
+ goto tcp_send_noopts;
+ }
+ }
+
+ goto drop;
+
+ case UIP_LAST_ACK:
+ /* We can close this connection if the peer has acknowledged our
+ FIN. This is indicated by the UIP_ACKDATA flag. */
+ if(uip_flags & UIP_ACKDATA) {
+ uip_connr->tcpstateflags = UIP_CLOSED;
+ uip_flags = UIP_CLOSE;
+ UIP_APPCALL();
+ }
+ break;
+
+ case UIP_FIN_WAIT_1:
+ /* The application has closed the connection, but the remote host
+ hasn't closed its end yet. Thus we do nothing but wait for a
+ FIN from the other side. */
+ if(uip_len > 0) {
+ uip_add_rcv_nxt(uip_len);
+ }
+
+ if(BUF->flags & TCP_FIN) {
+ if(uip_flags & UIP_ACKDATA) {
+ uip_connr->tcpstateflags = UIP_TIME_WAIT;
+ uip_connr->timer = 0;
+ uip_connr->len = 0;
+ }
+ else {
+ uip_connr->tcpstateflags = UIP_CLOSING;
+ }
+
+ uip_add_rcv_nxt(1);
+ uip_flags = UIP_CLOSE;
+ UIP_APPCALL();
+ goto tcp_send_ack;
+ }
+ else
+ if(uip_flags & UIP_ACKDATA) {
+ uip_connr->tcpstateflags = UIP_FIN_WAIT_2;
+ uip_connr->len = 0;
+ goto drop;
+ }
+
+ if(uip_len > 0) {
+ goto tcp_send_ack;
+ }
+
+ goto drop;
+
+ case UIP_FIN_WAIT_2:
+ if(uip_len > 0) {
+ uip_add_rcv_nxt(uip_len);
+ }
+
+ if(BUF->flags & TCP_FIN) {
+ uip_connr->tcpstateflags = UIP_TIME_WAIT;
+ uip_connr->timer = 0;
+ uip_add_rcv_nxt(1);
+ uip_flags = UIP_CLOSE;
+ UIP_APPCALL();
+ goto tcp_send_ack;
+ }
+
+ if(uip_len > 0) {
+ goto tcp_send_ack;
+ }
+
+ goto drop;
+
+ case UIP_TIME_WAIT:
+ goto tcp_send_ack;
+
+ case UIP_CLOSING:
+ if(uip_flags & UIP_ACKDATA) {
+ uip_connr->tcpstateflags = UIP_TIME_WAIT;
+ uip_connr->timer = 0;
+ }
+ }
+
+ goto drop;
+
+ /* We jump here when we are ready to send the packet, and just want
+ to set the appropriate TCP sequence numbers in the TCP header. */
+tcp_send_ack:
+ BUF->flags = TCP_ACK;
+tcp_send_nodata:
+ uip_len = UIP_IPTCPH_LEN;
+tcp_send_noopts:
+ BUF->tcpoffset = (UIP_TCPH_LEN / 4) << 4;
+tcp_send:
+ /* We're done with the input processing. We are now ready to send a
+ reply. Our job is to fill in all the fields of the TCP and IP
+ headers before calculating the checksum and finally send the
+ packet. */
+ BUF->ackno[0] = uip_connr->rcv_nxt[0];
+ BUF->ackno[1] = uip_connr->rcv_nxt[1];
+ BUF->ackno[2] = uip_connr->rcv_nxt[2];
+ BUF->ackno[3] = uip_connr->rcv_nxt[3];
+
+ BUF->seqno[0] = uip_connr->snd_nxt[0];
+ BUF->seqno[1] = uip_connr->snd_nxt[1];
+ BUF->seqno[2] = uip_connr->snd_nxt[2];
+ BUF->seqno[3] = uip_connr->snd_nxt[3];
+
+ BUF->proto = UIP_PROTO_TCP;
+
+ BUF->srcport = uip_connr->lport;
+ BUF->destport = uip_connr->rport;
+
+ uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
+ uip_ipaddr_copy(BUF->destipaddr, uip_connr->ripaddr);
+
+ if(uip_connr->tcpstateflags & UIP_STOPPED) {
+
+ /* If the connection has issued uip_stop(), we advertise a zero
+ window so that the remote host will stop sending data. */
+ BUF->wnd[0] = BUF->wnd[1] = 0;
+ }
+ else {
+ BUF->wnd[0] = ((UIP_RECEIVE_WINDOW) >> 8);
+ BUF->wnd[1] = ((UIP_RECEIVE_WINDOW) & 0xff);
+ }
+
+tcp_send_noconn:
+ BUF->ttl = UIP_TTL;
+#if UIP_CONF_IPV6
+ /* For IPv6, the IP length field does not include the IPv6 IP header
+ length. */
+
+ BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);
+ BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);
+#else /* UIP_CONF_IPV6 */
+ BUF->len[0] = (uip_len >> 8);
+ BUF->len[1] = (uip_len & 0xff);
+#endif /* UIP_CONF_IPV6 */
+
+ BUF->urgp[0] = BUF->urgp[1] = 0;
+
+ /* Calculate TCP checksum. */
+ BUF->tcpchksum = 0;
+ BUF->tcpchksum = ~(uip_tcpchksum());
+
+ip_send_nolen:
+#if UIP_CONF_IPV6
+ BUF->vtc = 0x60;
+ BUF->tcflow = 0x00;
+ BUF->flow = 0x00;
+#else /* UIP_CONF_IPV6 */
+ BUF->vhl = 0x45;
+ BUF->tos = 0;
+ BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
+ ++ipid;
+ BUF->ipid[0] = ipid >> 8;
+ BUF->ipid[1] = ipid & 0xff;
+
+ /* Calculate IP checksum. */
+ BUF->ipchksum = 0;
+ BUF->ipchksum = ~(uip_ipchksum());
+ DEBUG_PRINTF("uip ip_send_nolen: chkecum 0x%04x\n", uip_ipchksum());
+#endif /* UIP_CONF_IPV6 */
+
+ UIP_STAT(++uip_stat.tcp.sent);
+send:
+ DEBUG_PRINTF("Sending packet with length %d (%d)\n", uip_len, (BUF->len[0] << 8) | BUF->len[1]);
+
+ UIP_STAT(++uip_stat.ip.sent);
+
+ /* Return and let the caller do the actual transmission. */
+ uip_flags = 0;
+ return;
+drop:
+ uip_len = 0;
+ uip_flags = 0;
+ return;
+}
+
+/*---------------------------------------------------------------------------*/
+u16_t htons(u16_t val) {
+ return HTONS(val);
+}
+
+/*---------------------------------------------------------------------------*/
+void uip_send(const void* data, int len) {
+ uip_slen = len;
+ if(len > 0) {
+ if(data != uip_sappdata) {
+ memcpy(uip_sappdata, (data), uip_slen);
+ }
+ }
+}
+
+/** @} */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/uip.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,1657 @@
+
+/**
+ * \addtogroup uip
+ * @{
+ */
+
+/**
+ * \file
+ * Header file for the uIP TCP/IP stack.
+ * \author Adam Dunkels <adam@dunkels.com>
+ *
+ * The uIP TCP/IP stack header file contains definitions for a number
+ * of C macros that are used by uIP programs as well as internal uIP
+ * structures, TCP/IP header structures and function declarations.
+ *
+ */
+/*
+ * Copyright (c) 2001-2003, Adam Dunkels.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack.
+ *
+ * $Id: uip.h,v 1.40 2006/06/08 07:12:07 adam Exp $
+ *
+ */
+#ifndef __UIP_H__
+ #define __UIP_H__
+
+ #include "uipopt.h"
+
+/**
+ * Repressentation of an IP address.
+ *
+ */
+
+typedef u16_t uip_ip4addr_t[2];
+typedef u16_t uip_ip6addr_t[8];
+ #if UIP_CONF_IPV6
+typedef uip_ip6addr_t uip_ipaddr_t;
+ #else /* UIP_CONF_IPV6 */
+
+typedef uip_ip4addr_t uip_ipaddr_t;
+ #endif /* UIP_CONF_IPV6 */
+
+/*---------------------------------------------------------------------------*/
+
+/* First, the functions that should be called from the
+ * system. Initialization, the periodic timer and incoming packets are
+ * handled by the following three functions.
+ */
+/**
+ * \defgroup uipconffunc uIP configuration functions
+ * @{
+ *
+ * The uIP configuration functions are used for setting run-time
+ * parameters in uIP such as IP addresses.
+ */
+
+/**
+ * Set the IP address of this host.
+ *
+ * The IP address is represented as a 4-byte array where the first
+ * octet of the IP address is put in the first member of the 4-byte
+ * array.
+ *
+ * Example:
+ \code
+
+ uip_ipaddr_t addr;
+
+ uip_ipaddr(&addr, 192,168,1,2);
+ uip_sethostaddr(&addr);
+
+ \endcode
+ * \param addr A pointer to an IP address of type uip_ipaddr_t;
+ *
+ * \sa uip_ipaddr()
+ *
+ * \hideinitializer
+ */
+ #define uip_sethostaddr(addr) uip_ipaddr_copy(uip_hostaddr, (addr))
+
+/**
+ * Get the IP address of this host.
+ *
+ * The IP address is represented as a 4-byte array where the first
+ * octet of the IP address is put in the first member of the 4-byte
+ * array.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t hostaddr;
+
+ uip_gethostaddr(&hostaddr);
+ \endcode
+ * \param addr A pointer to a uip_ipaddr_t variable that will be
+ * filled in with the currently configured IP address.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_gethostaddr(addr) uip_ipaddr_copy((addr), uip_hostaddr)
+
+/**
+ * Set the default router's IP address.
+ *
+ * \param addr A pointer to a uip_ipaddr_t variable containing the IP
+ * address of the default router.
+ *
+ * \sa uip_ipaddr()
+ *
+ * \hideinitializer
+ */
+
+ #define uip_setdraddr(addr) uip_ipaddr_copy(uip_draddr, (addr))
+
+/**
+ * Set the netmask.
+ *
+ * \param addr A pointer to a uip_ipaddr_t variable containing the IP
+ * address of the netmask.
+ *
+ * \sa uip_ipaddr()
+ *
+ * \hideinitializer
+ */
+
+ #define uip_setnetmask(addr) uip_ipaddr_copy(uip_netmask, (addr))
+
+/**
+ * Get the default router's IP address.
+ *
+ * \param addr A pointer to a uip_ipaddr_t variable that will be
+ * filled in with the IP address of the default router.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_getdraddr(addr) uip_ipaddr_copy((addr), uip_draddr)
+
+/**
+ * Get the netmask.
+ *
+ * \param addr A pointer to a uip_ipaddr_t variable that will be
+ * filled in with the value of the netmask.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_getnetmask(addr) uip_ipaddr_copy((addr), uip_netmask)
+
+/** @} */
+
+/**
+ * \defgroup uipinit uIP initialization functions
+ * @{
+ *
+ * The uIP initialization functions are used for booting uIP.
+ */
+/**
+ * uIP initialization function.
+ *
+ * This function should be called at boot up to initilize the uIP
+ * TCP/IP stack.
+ */
+void uip_init(void);
+
+/**
+ * uIP initialization function.
+ *
+ * This function may be used at boot time to set the initial ip_id.
+ */
+void uip_setipid(u16_t id);
+
+/** @} */
+
+/**
+ * \defgroup uipdevfunc uIP device driver functions
+ * @{
+ *
+ * These functions are used by a network device driver for interacting
+ * with uIP.
+ */
+
+/**
+ * Process an incoming packet.
+ *
+ * This function should be called when the device driver has received
+ * a packet from the network. The packet from the device driver must
+ * be present in the uip_buf buffer, and the length of the packet
+ * should be placed in the uip_len variable.
+ *
+ * When the function returns, there may be an outbound packet placed
+ * in the uip_buf packet buffer. If so, the uip_len variable is set to
+ * the length of the packet. If no packet is to be sent out, the
+ * uip_len variable is set to 0.
+ *
+ * The usual way of calling the function is presented by the source
+ * code below.
+ \code
+ uip_len = devicedriver_poll();
+ if(uip_len > 0) {
+ uip_input();
+ if(uip_len > 0) {
+ devicedriver_send();
+ }
+ }
+ \endcode
+ *
+ * \note If you are writing a uIP device driver that needs ARP
+ * (Address Resolution Protocol), e.g., when running uIP over
+ * Ethernet, you will need to call the uIP ARP code before calling
+ * this function:
+ \code
+ #define BUF ((struct uip_eth_hdr *)&uip_buf[0])
+ uip_len = ethernet_devicedrver_poll();
+ if(uip_len > 0) {
+ if(BUF->type == HTONS(UIP_ETHTYPE_IP)) {
+ uip_arp_ipin();
+ uip_input();
+ if(uip_len > 0) {
+ uip_arp_out();
+ ethernet_devicedriver_send();
+ }
+ } else if(BUF->type == HTONS(UIP_ETHTYPE_ARP)) {
+ uip_arp_arpin();
+ if(uip_len > 0) {
+ ethernet_devicedriver_send();
+ }
+ }
+ \endcode
+ *
+ * \hideinitializer
+ */
+ #define uip_input() uip_process(UIP_DATA)
+
+/**
+ * Periodic processing for a connection identified by its number.
+ *
+ * This function does the necessary periodic processing (timers,
+ * polling) for a uIP TCP conneciton, and should be called when the
+ * periodic uIP timer goes off. It should be called for every
+ * connection, regardless of whether they are open of closed.
+ *
+ * When the function returns, it may have an outbound packet waiting
+ * for service in the uIP packet buffer, and if so the uip_len
+ * variable is set to a value larger than zero. The device driver
+ * should be called to send out the packet.
+ *
+ * The ususal way of calling the function is through a for() loop like
+ * this:
+ \code
+ for(i = 0; i < UIP_CONNS; ++i) {
+ uip_periodic(i);
+ if(uip_len > 0) {
+ devicedriver_send();
+ }
+ }
+ \endcode
+ *
+ * \note If you are writing a uIP device driver that needs ARP
+ * (Address Resolution Protocol), e.g., when running uIP over
+ * Ethernet, you will need to call the uip_arp_out() function before
+ * calling the device driver:
+ \code
+ for(i = 0; i < UIP_CONNS; ++i) {
+ uip_periodic(i);
+ if(uip_len > 0) {
+ uip_arp_out();
+ ethernet_devicedriver_send();
+ }
+ }
+ \endcode
+ *
+ * \param conn The number of the connection which is to be periodically polled.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_periodic(conn) \
+ do \
+ { \
+ uip_conn = &uip_conns[conn]; \
+ uip_process(UIP_TIMER); \
+ } while(0)
+
+/**
+ *
+ *
+ */
+
+ #define uip_conn_active(conn) (uip_conns[conn].tcpstateflags != UIP_CLOSED)
+
+/**
+ * Perform periodic processing for a connection identified by a pointer
+ * to its structure.
+ *
+ * Same as uip_periodic() but takes a pointer to the actual uip_conn
+ * struct instead of an integer as its argument. This function can be
+ * used to force periodic processing of a specific connection.
+ *
+ * \param conn A pointer to the uip_conn struct for the connection to
+ * be processed.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_periodic_conn(conn) \
+ do \
+ { \
+ uip_conn = conn; \
+ uip_process(UIP_TIMER); \
+ } while(0)
+
+/**
+ * Reuqest that a particular connection should be polled.
+ *
+ * Similar to uip_periodic_conn() but does not perform any timer
+ * processing. The application is polled for new data.
+ *
+ * \param conn A pointer to the uip_conn struct for the connection to
+ * be processed.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_poll_conn(conn) \
+ do \
+ { \
+ uip_conn = conn; \
+ uip_process(UIP_POLL_REQUEST); \
+ } while(0)
+ #if UIP_UDP
+
+/**
+ * Periodic processing for a UDP connection identified by its number.
+ *
+ * This function is essentially the same as uip_periodic(), but for
+ * UDP connections. It is called in a similar fashion as the
+ * uip_periodic() function:
+ \code
+ for(i = 0; i < UIP_UDP_CONNS; i++) {
+ uip_udp_periodic(i);
+ if(uip_len > 0) {
+ devicedriver_send();
+ }
+ }
+ \endcode
+ *
+ * \note As for the uip_periodic() function, special care has to be
+ * taken when using uIP together with ARP and Ethernet:
+ \code
+ for(i = 0; i < UIP_UDP_CONNS; i++) {
+ uip_udp_periodic(i);
+ if(uip_len > 0) {
+ uip_arp_out();
+ ethernet_devicedriver_send();
+ }
+ }
+ \endcode
+ *
+ * \param conn The number of the UDP connection to be processed.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_udp_periodic(conn) \
+ do \
+ { \
+ uip_udp_conn = &uip_udp_conns[conn]; \
+ uip_process(UIP_UDP_TIMER); \
+ } while(0)
+
+/**
+ * Periodic processing for a UDP connection identified by a pointer to
+ * its structure.
+ *
+ * Same as uip_udp_periodic() but takes a pointer to the actual
+ * uip_conn struct instead of an integer as its argument. This
+ * function can be used to force periodic processing of a specific
+ * connection.
+ *
+ * \param conn A pointer to the uip_udp_conn struct for the connection
+ * to be processed.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_udp_periodic_conn(conn) \
+ do \
+ { \
+ uip_udp_conn = conn; \
+ uip_process(UIP_UDP_TIMER); \
+ } while(0)
+ #endif /* UIP_UDP */
+
+ /**
+ * The uIP packet buffer.
+ *
+ * The uip_buf array is used to hold incoming and outgoing
+ * packets. The device driver should place incoming data into this
+ * buffer. When sending data, the device driver should read the link
+ * level headers and the TCP/IP headers from this buffer. The size of
+ * the link level headers is configured by the UIP_LLH_LEN define.
+ *
+ * \note The application data need not be placed in this buffer, so
+ * the device driver must read it from the place pointed to by the
+ * uip_appdata pointer as illustrated by the following example:
+ \code
+ void
+ devicedriver_send(void)
+ {
+ hwsend(&uip_buf[0], UIP_LLH_LEN);
+ if(uip_len <= UIP_LLH_LEN + UIP_TCPIP_HLEN) {
+ hwsend(&uip_buf[UIP_LLH_LEN], uip_len - UIP_LLH_LEN);
+ } else {
+ hwsend(&uip_buf[UIP_LLH_LEN], UIP_TCPIP_HLEN);
+ hwsend(uip_appdata, uip_len - UIP_TCPIP_HLEN - UIP_LLH_LEN);
+ }
+ }
+ \endcode
+ */
+ extern u8_t uip_buf[UIP_BUFSIZE + 2];
+
+/** @} */
+
+/*---------------------------------------------------------------------------*/
+/* Functions that are used by the uIP application program. Opening and
+ * closing connections, sending and receiving data, etc. is all
+ * handled by the functions below.
+*/
+/**
+ * \defgroup uipappfunc uIP application functions
+ * @{
+ *
+ * Functions used by an application running of top of uIP.
+ */
+/**
+ * Start listening to the specified port.
+ *
+ * \note Since this function expects the port number in network byte
+ * order, a conversion using HTONS() or htons() is necessary.
+ *
+ \code
+ uip_listen(HTONS(80));
+ \endcode
+ *
+ * \param port A 16-bit port number in network byte order.
+ */
+void uip_listen(u16_t port);
+
+/**
+ * Stop listening to the specified port.
+ *
+ * \note Since this function expects the port number in network byte
+ * order, a conversion using HTONS() or htons() is necessary.
+ *
+ \code
+ uip_unlisten(HTONS(80));
+ \endcode
+ *
+ * \param port A 16-bit port number in network byte order.
+ */
+void uip_unlisten(u16_t port);
+
+/**
+ * Connect to a remote host using TCP.
+ *
+ * This function is used to start a new connection to the specified
+ * port on the specied host. It allocates a new connection identifier,
+ * sets the connection to the SYN_SENT state and sets the
+ * retransmission timer to 0. This will cause a TCP SYN segment to be
+ * sent out the next time this connection is periodically processed,
+ * which usually is done within 0.5 seconds after the call to
+ * uip_connect().
+ *
+ * \note This function is avaliable only if support for active open
+ * has been configured by defining UIP_ACTIVE_OPEN to 1 in uipopt.h.
+ *
+ * \note Since this function requires the port number to be in network
+ * byte order, a conversion using HTONS() or htons() is necessary.
+ *
+ \code
+ uip_ipaddr_t ipaddr;
+
+ uip_ipaddr(&ipaddr, 192,168,1,2);
+ uip_connect(&ipaddr, HTONS(80));
+ \endcode
+ *
+ * \param ripaddr The IP address of the remote hot.
+ *
+ * \param port A 16-bit port number in network byte order.
+ *
+ * \return A pointer to the uIP connection identifier for the new connection,
+ * or NULL if no connection could be allocated.
+ *
+ */
+struct uip_conn* uip_connect(uip_ipaddr_t* ripaddr, u16_t port);
+
+/**
+ * \internal
+ *
+ * Check if a connection has outstanding (i.e., unacknowledged) data.
+ *
+ * \param conn A pointer to the uip_conn structure for the connection.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_outstanding(conn) ((conn)->len)
+
+/**
+ * Send data on the current connection.
+ *
+ * This function is used to send out a single segment of TCP
+ * data. Only applications that have been invoked by uIP for event
+ * processing can send data.
+ *
+ * The amount of data that actually is sent out after a call to this
+ * funcion is determined by the maximum amount of data TCP allows. uIP
+ * will automatically crop the data so that only the appropriate
+ * amount of data is sent. The function uip_mss() can be used to query
+ * uIP for the amount of data that actually will be sent.
+ *
+ * \note This function does not guarantee that the sent data will
+ * arrive at the destination. If the data is lost in the network, the
+ * application will be invoked with the uip_rexmit() event being
+ * set. The application will then have to resend the data using this
+ * function.
+ *
+ * \param data A pointer to the data which is to be sent.
+ *
+ * \param len The maximum amount of data bytes to be sent.
+ *
+ * \hideinitializer
+ */
+void uip_send(const void* data, int len);
+
+/**
+ * The length of any incoming data that is currently avaliable (if avaliable)
+ * in the uip_appdata buffer.
+ *
+ * The test function uip_data() must first be used to check if there
+ * is any data available at all.
+ *
+ * \hideinitializer
+ */
+
+/*void uip_datalen(void);*/
+ #define uip_datalen() uip_len
+
+/**
+ * The length of any out-of-band data (urgent data) that has arrived
+ * on the connection.
+ *
+ * \note The configuration parameter UIP_URGDATA must be set for this
+ * function to be enabled.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_urgdatalen() uip_urglen
+
+/**
+ * Close the current connection.
+ *
+ * This function will close the current connection in a nice way.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_close() (uip_flags = UIP_CLOSE)
+
+/**
+ * Abort the current connection.
+ *
+ * This function will abort (reset) the current connection, and is
+ * usually used when an error has occured that prevents using the
+ * uip_close() function.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_abort() (uip_flags = UIP_ABORT)
+
+/**
+ * Tell the sending host to stop sending data.
+ *
+ * This function will close our receiver's window so that we stop
+ * receiving data for the current connection.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_stop() (uip_conn->tcpstateflags |= UIP_STOPPED)
+
+/**
+ * Find out if the current connection has been previously stopped with
+ * uip_stop().
+ *
+ * \hideinitializer
+ */
+
+ #define uip_stopped(conn) ((conn)->tcpstateflags & UIP_STOPPED)
+
+/**
+ * Restart the current connection, if is has previously been stopped
+ * with uip_stop().
+ *
+ * This function will open the receiver's window again so that we
+ * start receiving data for the current connection.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_restart() \
+ do \
+ { \
+ uip_flags |= UIP_NEWDATA; \
+ uip_conn->tcpstateflags &= ~UIP_STOPPED; \
+ } while(0)
+
+ /* uIP tests that can be made to determine in what state the current
+ connection is, and what the application function should do. */
+
+/**
+ * Is the current connection a UDP connection?
+ *
+ * This function checks whether the current connection is a UDP connection.
+ *
+ * \hideinitializer
+ *
+ */
+ #define uip_udpconnection() (uip_conn == NULL)
+
+/**
+ * Is new incoming data available?
+ *
+ * Will reduce to non-zero if there is new data for the application
+ * present at the uip_appdata pointer. The size of the data is
+ * avaliable through the uip_len variable.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_newdata() (uip_flags & UIP_NEWDATA)
+
+/**
+ * Has previously sent data been acknowledged?
+ *
+ * Will reduce to non-zero if the previously sent data has been
+ * acknowledged by the remote host. This means that the application
+ * can send new data.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_acked() (uip_flags & UIP_ACKDATA)
+
+/**
+ * Has the connection just been connected?
+ *
+ * Reduces to non-zero if the current connection has been connected to
+ * a remote host. This will happen both if the connection has been
+ * actively opened (with uip_connect()) or passively opened (with
+ * uip_listen()).
+ *
+ * \hideinitializer
+ */
+
+ #define uip_connected() (uip_flags & UIP_CONNECTED)
+
+/**
+ * Has the connection been closed by the other end?
+ *
+ * Is non-zero if the connection has been closed by the remote
+ * host. The application may then do the necessary clean-ups.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_closed() (uip_flags & UIP_CLOSE)
+
+/**
+ * Has the connection been aborted by the other end?
+ *
+ * Non-zero if the current connection has been aborted (reset) by the
+ * remote host.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_aborted() (uip_flags & UIP_ABORT)
+
+/**
+ * Has the connection timed out?
+ *
+ * Non-zero if the current connection has been aborted due to too many
+ * retransmissions.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_timedout() (uip_flags & UIP_TIMEDOUT)
+
+/**
+ * Do we need to retransmit previously data?
+ *
+ * Reduces to non-zero if the previously sent data has been lost in
+ * the network, and the application should retransmit it. The
+ * application should send the exact same data as it did the last
+ * time, using the uip_send() function.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_rexmit() (uip_flags & UIP_REXMIT)
+
+/**
+ * Is the connection being polled by uIP?
+ *
+ * Is non-zero if the reason the application is invoked is that the
+ * current connection has been idle for a while and should be
+ * polled.
+ *
+ * The polling event can be used for sending data without having to
+ * wait for the remote host to send data.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_poll() (uip_flags & UIP_POLL)
+
+/**
+ * Get the initial maxium segment size (MSS) of the current
+ * connection.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_initialmss() (uip_conn->initialmss)
+
+/**
+ * Get the current maxium segment size that can be sent on the current
+ * connection.
+ *
+ * The current maxiumum segment size that can be sent on the
+ * connection is computed from the receiver's window and the MSS of
+ * the connection (which also is available by calling
+ * uip_initialmss()).
+ *
+ * \hideinitializer
+ */
+
+ #define uip_mss() (uip_conn->mss)
+ /**
+ * Set up a new UDP connection.
+ *
+ * This function sets up a new UDP connection. The function will
+ * automatically allocate an unused local port for the new
+ * connection. However, another port can be chosen by using the
+ * uip_udp_bind() call, after the uip_udp_new() function has been
+ * called.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t addr;
+ struct uip_udp_conn *c;
+
+ uip_ipaddr(&addr, 192,168,2,1);
+ c = uip_udp_new(&addr, HTONS(12345));
+ if(c != NULL) {
+ uip_udp_bind(c, HTONS(12344));
+ }
+ \endcode
+ * \param ripaddr The IP address of the remote host.
+ *
+ * \param rport The remote port number in network byte order.
+ *
+ * \return The uip_udp_conn structure for the new connection or NULL
+ * if no connection could be allocated.
+ */
+ struct uip_udp_conn* uip_udp_new(uip_ipaddr_t* ripaddr, u16_t rport);
+
+/**
+ * Removed a UDP connection.
+ *
+ * \param conn A pointer to the uip_udp_conn structure for the connection.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_udp_remove(conn) (conn)->lport = 0
+
+/**
+ * Bind a UDP connection to a local port.
+ *
+ * \param conn A pointer to the uip_udp_conn structure for the
+ * connection.
+ *
+ * \param port The local port number, in network byte order.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_udp_bind(conn, port) (conn)->lport = port
+
+/**
+ * Send a UDP datagram of length len on the current connection.
+ *
+ * This function can only be called in response to a UDP event (poll
+ * or newdata). The data must be present in the uip_buf buffer, at the
+ * place pointed to by the uip_appdata pointer.
+ *
+ * \param len The length of the data in the uip_buf buffer.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_udp_send(len) uip_send((char*)uip_appdata, len)
+
+/** @} */
+
+/* uIP convenience and converting functions. */
+/**
+ * \defgroup uipconvfunc uIP conversion functions
+ * @{
+ *
+ * These functions can be used for converting between different data
+ * formats used by uIP.
+ */
+
+/**
+ * Construct an IP address from four bytes.
+ *
+ * This function constructs an IP address of the type that uIP handles
+ * internally from four bytes. The function is handy for specifying IP
+ * addresses to use with e.g. the uip_connect() function.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr;
+ struct uip_conn *c;
+
+ uip_ipaddr(&ipaddr, 192,168,1,2);
+ c = uip_connect(&ipaddr, HTONS(80));
+ \endcode
+ *
+ * \param addr A pointer to a uip_ipaddr_t variable that will be
+ * filled in with the IP address.
+ *
+ * \param addr0 The first octet of the IP address.
+ * \param addr1 The second octet of the IP address.
+ * \param addr2 The third octet of the IP address.
+ * \param addr3 The forth octet of the IP address.
+ *
+ * \hideinitializer
+ */
+ #define uip_ipaddr(addr, addr0, addr1, addr2, addr3) \
+ do \
+ { \
+ ((u16_t *) (addr))[0] = HTONS(((addr0) << 8) | (addr1)); \
+ ((u16_t *) (addr))[1] = HTONS(((addr2) << 8) | (addr3)); \
+ } while(0)
+
+/**
+ * Construct an IPv6 address from eight 16-bit words.
+ *
+ * This function constructs an IPv6 address.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_ip6addr(addr, addr0, addr1, addr2, addr3, addr4, addr5, addr6, addr7) \
+ do \
+ { \
+ ((u16_t *) (addr))[0] = HTONS((addr0)); \
+ ((u16_t *) (addr))[1] = HTONS((addr1)); \
+ ((u16_t *) (addr))[2] = HTONS((addr2)); \
+ ((u16_t *) (addr))[3] = HTONS((addr3)); \
+ ((u16_t *) (addr))[4] = HTONS((addr4)); \
+ ((u16_t *) (addr))[5] = HTONS((addr5)); \
+ ((u16_t *) (addr))[6] = HTONS((addr6)); \
+ ((u16_t *) (addr))[7] = HTONS((addr7)); \
+ } while(0) /**
+ * Copy an IP address to another IP address.
+ *
+ * Copies an IP address from one place to another.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr1, ipaddr2;
+
+ uip_ipaddr(&ipaddr1, 192,16,1,2);
+ uip_ipaddr_copy(&ipaddr2, &ipaddr1);
+ \endcode
+ *
+ * \param dest The destination for the copy.
+ * \param src The source from where to copy.
+ *
+ * \hideinitializer
+ */
+
+ #if !UIP_CONF_IPV6
+ #define uip_ipaddr_copy(dest, src) \
+ do \
+ { \
+ ((u16_t*)dest)[0] = ((u16_t*)src)[0]; \
+ ((u16_t*)dest)[1] = ((u16_t*)src)[1]; \
+ } while(0)
+ #else /* !UIP_CONF_IPV6 */
+
+ #define uip_ipaddr_copy(dest, src) memcpy(dest, src, sizeof(uip_ip6addr_t))
+ #endif /* !UIP_CONF_IPV6 */
+
+ /**
+ * Compare two IP addresses
+ *
+ * Compares two IP addresses.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr1, ipaddr2;
+
+ uip_ipaddr(&ipaddr1, 192,16,1,2);
+ if(uip_ipaddr_cmp(&ipaddr2, &ipaddr1)) {
+ printf("They are the same");
+ }
+ \endcode
+ *
+ * \param addr1 The first IP address.
+ * \param addr2 The second IP address.
+ *
+ * \hideinitializer
+ */
+
+ #if !UIP_CONF_IPV6
+ #define uip_ipaddr_cmp(addr1, addr2) \
+ (((u16_t*)addr1)[0] == ((u16_t*)addr2)[0] && ((u16_t*)addr1)[1] == ((u16_t*)addr2)[1])
+ #else /* !UIP_CONF_IPV6 */
+
+ #define uip_ipaddr_cmp(addr1, addr2) (memcmp(addr1, addr2, sizeof(uip_ip6addr_t)) == 0)
+ #endif /* !UIP_CONF_IPV6 */
+
+/**
+ * Compare two IP addresses with netmasks
+ *
+ * Compares two IP addresses with netmasks. The masks are used to mask
+ * out the bits that are to be compared.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr1, ipaddr2, mask;
+
+ uip_ipaddr(&mask, 255,255,255,0);
+ uip_ipaddr(&ipaddr1, 192,16,1,2);
+ uip_ipaddr(&ipaddr2, 192,16,1,3);
+ if(uip_ipaddr_maskcmp(&ipaddr1, &ipaddr2, &mask)) {
+ printf("They are the same");
+ }
+ \endcode
+ *
+ * \param addr1 The first IP address.
+ * \param addr2 The second IP address.
+ * \param mask The netmask.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_ipaddr_maskcmp(addr1, addr2, mask) \
+ ( \
+ ((((u16_t*)addr1)[0] & ((u16_t*)mask)[0]) == (((u16_t*)addr2)[0] & ((u16_t*)mask)[0])) \
+ && ((((u16_t*)addr1)[1] & ((u16_t*)mask)[1]) == (((u16_t*)addr2)[1] & ((u16_t*)mask)[1])) \
+ )
+
+/**
+ * Mask out the network part of an IP address.
+ *
+ * Masks out the network part of an IP address, given the address and
+ * the netmask.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr1, ipaddr2, netmask;
+
+ uip_ipaddr(&ipaddr1, 192,16,1,2);
+ uip_ipaddr(&netmask, 255,255,255,0);
+ uip_ipaddr_mask(&ipaddr2, &ipaddr1, &netmask);
+ \endcode
+ *
+ * In the example above, the variable "ipaddr2" will contain the IP
+ * address 192.168.1.0.
+ *
+ * \param dest Where the result is to be placed.
+ * \param src The IP address.
+ * \param mask The netmask.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_ipaddr_mask(dest, src, mask) \
+ do \
+ { \
+ ((u16_t*)dest)[0] = ((u16_t*)src)[0] & ((u16_t*)mask)[0]; \
+ ((u16_t*)dest)[1] = ((u16_t*)src)[1] & ((u16_t*)mask)[1]; \
+ } while(0)
+
+/**
+ * Pick the first octet of an IP address.
+ *
+ * Picks out the first octet of an IP address.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr;
+ u8_t octet;
+
+ uip_ipaddr(&ipaddr, 1,2,3,4);
+ octet = uip_ipaddr1(&ipaddr);
+ \endcode
+ *
+ * In the example above, the variable "octet" will contain the value 1.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_ipaddr1(addr) (htons(((u16_t *) (addr))[0]) >> 8)
+
+/**
+ * Pick the second octet of an IP address.
+ *
+ * Picks out the second octet of an IP address.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr;
+ u8_t octet;
+
+ uip_ipaddr(&ipaddr, 1,2,3,4);
+ octet = uip_ipaddr2(&ipaddr);
+ \endcode
+ *
+ * In the example above, the variable "octet" will contain the value 2.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_ipaddr2(addr) (htons(((u16_t *) (addr))[0]) & 0xff)
+
+/**
+ * Pick the third octet of an IP address.
+ *
+ * Picks out the third octet of an IP address.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr;
+ u8_t octet;
+
+ uip_ipaddr(&ipaddr, 1,2,3,4);
+ octet = uip_ipaddr3(&ipaddr);
+ \endcode
+ *
+ * In the example above, the variable "octet" will contain the value 3.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_ipaddr3(addr) (htons(((u16_t *) (addr))[1]) >> 8)
+
+/**
+ * Pick the fourth octet of an IP address.
+ *
+ * Picks out the fourth octet of an IP address.
+ *
+ * Example:
+ \code
+ uip_ipaddr_t ipaddr;
+ u8_t octet;
+
+ uip_ipaddr(&ipaddr, 1,2,3,4);
+ octet = uip_ipaddr4(&ipaddr);
+ \endcode
+ *
+ * In the example above, the variable "octet" will contain the value 4.
+ *
+ * \hideinitializer
+ */
+
+ #define uip_ipaddr4(addr) (htons(((u16_t *) (addr))[1]) & 0xff)
+ /**
+ * Convert 16-bit quantity from host byte order to network byte order.
+ *
+ * This macro is primarily used for converting constants from host
+ * byte order to network byte order. For converting variables to
+ * network byte order, use the htons() function instead.
+ *
+ * \hideinitializer
+ */
+
+ #ifndef HTONS
+ #if UIP_BYTE_ORDER == UIP_BIG_ENDIAN
+ #define HTONS(n) (n)
+ #else /* UIP_BYTE_ORDER == UIP_BIG_ENDIAN */
+
+ #define HTONS(n) (u16_t) ((((u16_t) (n)) << 8) | (((u16_t) (n)) >> 8))
+ #endif /* UIP_BYTE_ORDER == UIP_BIG_ENDIAN */
+
+ #else
+ #error "HTONS already defined!"
+ #endif /* HTONS */
+
+ /**
+ * Convert 16-bit quantity from host byte order to network byte order.
+ *
+ * This function is primarily used for converting variables from host
+ * byte order to network byte order. For converting constants to
+ * network byte order, use the HTONS() macro instead.
+ */
+
+ #ifndef htons
+ u16_t htons(u16_t val);
+ #endif /* htons */
+
+ #ifndef ntohs
+ #define ntohs htons
+ #endif
+/** @} */
+
+/**
+ * Pointer to the application data in the packet buffer.
+ *
+ * This pointer points to the application data when the application is
+ * called. If the application wishes to send data, the application may
+ * use this space to write the data into before calling uip_send().
+ */
+extern void* uip_appdata;
+
+ #if UIP_URGDATA > 0
+/* u8_t *uip_urgdata:
+ *
+ * This pointer points to any urgent data that has been received. Only
+ * present if compiled with support for urgent data (UIP_URGDATA).
+ */
+extern void* uip_urgdata;
+ #endif /* UIP_URGDATA > 0 */
+
+/**
+ * \defgroup uipdrivervars Variables used in uIP device drivers
+ * @{
+ *
+ * uIP has a few global variables that are used in device drivers for
+ * uIP.
+ */
+
+/**
+ * The length of the packet in the uip_buf buffer.
+ *
+ * The global variable uip_len holds the length of the packet in the
+ * uip_buf buffer.
+ *
+ * When the network device driver calls the uIP input function,
+ * uip_len should be set to the length of the packet in the uip_buf
+ * buffer.
+ *
+ * When sending packets, the device driver should use the contents of
+ * the uip_len variable to determine the length of the outgoing
+ * packet.
+ *
+ */
+extern u16_t uip_len;
+
+/** @} */
+ #if UIP_URGDATA > 0
+extern u16_t uip_urglen, uip_surglen;
+ #endif /* UIP_URGDATA > 0 */
+
+/**
+ * Representation of a uIP TCP connection.
+ *
+ * The uip_conn structure is used for identifying a connection. All
+ * but one field in the structure are to be considered read-only by an
+ * application. The only exception is the appstate field whos purpose
+ * is to let the application store application-specific state (e.g.,
+ * file pointers) for the connection. The type of this field is
+ * configured in the "uipopt.h" header file.
+ */
+
+struct uip_conn
+{
+ uip_ipaddr_t ripaddr; /**< The IP address of the remote host. */
+
+ u16_t lport; /**< The local TCP port, in network byte order. */
+ u16_t rport; /**< The local remote TCP port, in network byte
+ order. */
+
+ u8_t rcv_nxt[4]; /**< The sequence number that we expect to
+ receive next. */
+ u8_t snd_nxt[4]; /**< The sequence number that was last sent by
+ us. */
+ u16_t len; /**< Length of the data that was previously sent. */
+ u16_t mss; /**< Current maximum segment size for the
+ connection. */
+ u16_t initialmss; /**< Initial maximum segment size for the
+ connection. */
+ u8_t sa; /**< Retransmission time-out calculation state
+ variable. */
+ u8_t sv; /**< Retransmission time-out calculation state
+ variable. */
+ u8_t rto; /**< Retransmission time-out. */
+ u8_t tcpstateflags; /**< TCP state and flags. */
+ u8_t timer; /**< The retransmission timer. */
+ u8_t nrtx; /**< The number of retransmissions for the last
+ segment sent. */
+
+ /** The application state. */
+ uip_tcp_appstate_t appstate;
+};
+
+/**
+ * Pointer to the current TCP connection.
+ *
+ * The uip_conn pointer can be used to access the current TCP
+ * connection.
+ */
+extern struct uip_conn* uip_conn;
+
+/* The array containing all uIP connections. */
+extern struct uip_conn uip_conns[UIP_CONNS];
+
+/**
+ * \addtogroup uiparch
+ * @{
+ */
+/**
+ * 4-byte array used for the 32-bit sequence number calculations.
+ */
+extern u8_t uip_acc32[4];
+
+/** @} */
+
+ #if UIP_UDP
+
+/**
+ * Representation of a uIP UDP connection.
+ */
+struct uip_udp_conn
+{
+ uip_ipaddr_t ripaddr; /**< The IP address of the remote peer. */
+ u16_t lport; /**< The local port number in network byte order. */
+ u16_t rport; /**< The remote port number in network byte order. */
+ u8_t ttl; /**< Default time-to-live. */
+
+ /** The application state. */
+ uip_udp_appstate_t appstate;
+};
+
+/**
+ * The current UDP connection.
+ */
+extern struct uip_udp_conn* uip_udp_conn;
+extern struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
+ #endif /* UIP_UDP */
+
+/**
+ * The structure holding the TCP/IP statistics that are gathered if
+ * UIP_STATISTICS is set to 1.
+ *
+ */
+
+struct uip_stats
+{
+ struct
+ {
+ uip_stats_t drop; /**< Number of dropped packets at the IP
+ layer. */
+ uip_stats_t recv; /**< Number of received packets at the IP
+ layer. */
+ uip_stats_t sent; /**< Number of sent packets at the IP
+ layer. */
+ uip_stats_t vhlerr; /**< Number of packets dropped due to wrong
+ IP version or header length. */
+ uip_stats_t hblenerr; /**< Number of packets dropped due to wrong
+ IP length, high byte. */
+ uip_stats_t lblenerr; /**< Number of packets dropped due to wrong
+ IP length, low byte. */
+ uip_stats_t fragerr; /**< Number of packets dropped since they
+ were IP fragments. */
+ uip_stats_t chkerr; /**< Number of packets dropped due to IP
+ checksum errors. */
+ uip_stats_t protoerr; /**< Number of packets dropped since they
+ were neither ICMP, UDP nor TCP. */
+ } ip; /**< IP statistics. */
+ struct
+ {
+ uip_stats_t drop; /**< Number of dropped ICMP packets. */
+ uip_stats_t recv; /**< Number of received ICMP packets. */
+ uip_stats_t sent; /**< Number of sent ICMP packets. */
+ uip_stats_t typeerr; /**< Number of ICMP packets with a wrong
+ type. */
+ } icmp; /**< ICMP statistics. */
+ struct
+ {
+ uip_stats_t drop; /**< Number of dropped TCP segments. */
+ uip_stats_t recv; /**< Number of recived TCP segments. */
+ uip_stats_t sent; /**< Number of sent TCP segments. */
+ uip_stats_t chkerr; /**< Number of TCP segments with a bad
+ checksum. */
+ uip_stats_t ackerr; /**< Number of TCP segments with a bad ACK
+ number. */
+ uip_stats_t rst; /**< Number of recevied TCP RST (reset) segments. */
+ uip_stats_t rexmit; /**< Number of retransmitted TCP segments. */
+ uip_stats_t syndrop; /**< Number of dropped SYNs due to too few
+ connections was avaliable. */
+ uip_stats_t synrst; /**< Number of SYNs for closed ports,
+ triggering a RST. */
+ } tcp; /**< TCP statistics. */
+ #if UIP_UDP
+ struct
+ {
+ uip_stats_t drop; /**< Number of dropped UDP segments. */
+ uip_stats_t recv; /**< Number of recived UDP segments. */
+ uip_stats_t sent; /**< Number of sent UDP segments. */
+ uip_stats_t chkerr; /**< Number of UDP segments with a bad
+ checksum. */
+ } udp; /**< UDP statistics. */
+ #endif /* UIP_UDP */
+};
+
+/**
+ * The uIP TCP/IP statistics.
+ *
+ * This is the variable in which the uIP TCP/IP statistics are gathered.
+ */
+extern struct uip_stats uip_stat;
+
+/*---------------------------------------------------------------------------*/
+/* All the stuff below this point is internal to uIP and should not be
+ * used directly by an application or by a device driver.
+ */
+/*---------------------------------------------------------------------------*/
+/* u8_t uip_flags:
+ *
+ * When the application is called, uip_flags will contain the flags
+ * that are defined in this file. Please read below for more
+ * infomation.
+ */
+extern u8_t uip_flags;
+
+/* The following flags may be set in the global variable uip_flags
+ before calling the application callback. The UIP_ACKDATA,
+ UIP_NEWDATA, and UIP_CLOSE flags may both be set at the same time,
+ whereas the others are mutualy exclusive. Note that these flags
+ should *NOT* be accessed directly, but only through the uIP
+ functions/macros. */
+
+ #define UIP_ACKDATA 1 /* Signifies that the outstanding data was
+ acked and the application should send
+ out new data instead of retransmitting
+ the last data. */
+
+ #define UIP_NEWDATA 2 /* Flags the fact that the peer has sent
+ us new data. */
+
+ #define UIP_REXMIT 4 /* Tells the application to retransmit the
+ data that was last sent. */
+
+ #define UIP_POLL 8 /* Used for polling the application, to
+ check if the application has data that
+ it wants to send. */
+
+ #define UIP_CLOSE 16 /* The remote host has closed the
+ connection, thus the connection has
+ gone away. Or the application signals
+ that it wants to close the
+ connection. */
+
+ #define UIP_ABORT 32 /* The remote host has aborted the
+ connection, thus the connection has
+ gone away. Or the application signals
+ that it wants to abort the
+ connection. */
+
+ #define UIP_CONNECTED 64 /* We have got a connection from a remote
+ host and have set up a new connection
+ for it, or an active connection has
+ been successfully established. */
+
+ #define UIP_TIMEDOUT 128 /* The connection has been aborted due to
+ too many retransmissions. */
+
+/* uip_process(flag):
+ *
+ * The actual uIP function which does all the work.
+ */
+void uip_process(u8_t flag);
+
+/* The following flags are passed as an argument to the uip_process()
+ function. They are used to distinguish between the two cases where
+ uip_process() is called. It can be called either because we have
+ incoming data that should be processed, or because the periodic
+ timer has fired. These values are never used directly, but only in
+ the macrose defined in this file. */
+
+ #define UIP_DATA 1 /* Tells uIP that there is incoming
+ data in the uip_buf buffer. The
+ length of the data is stored in the
+ global variable uip_len. */
+
+ #define UIP_TIMER 2 /* Tells uIP that the periodic timer
+ has fired. */
+
+ #define UIP_POLL_REQUEST 3 /* Tells uIP that a connection should
+ be polled. */
+
+ #define UIP_UDP_SEND_CONN 4 /* Tells uIP that a UDP datagram
+ should be constructed in the
+ uip_buf buffer. */
+
+ #if UIP_UDP
+ #define UIP_UDP_TIMER 5
+ #endif /* UIP_UDP */
+
+/* The TCP states used in the uip_conn->tcpstateflags. */
+
+ #define UIP_CLOSED 0
+ #define UIP_SYN_RCVD 1
+ #define UIP_SYN_SENT 2
+ #define UIP_ESTABLISHED 3
+ #define UIP_FIN_WAIT_1 4
+ #define UIP_FIN_WAIT_2 5
+ #define UIP_CLOSING 6
+ #define UIP_TIME_WAIT 7
+ #define UIP_LAST_ACK 8
+ #define UIP_TS_MASK 15
+
+ #define UIP_STOPPED 16
+
+/* The TCP and IP headers. */
+struct uip_tcpip_hdr
+{
+ #if UIP_CONF_IPV6
+ /* IPv6 header. */
+ u8_t vtc, tcflow;
+ u16_t flow;
+ u8_t len[2];
+ u8_t proto, ttl;
+ uip_ip6addr_t srcipaddr, destipaddr;
+ #else /* UIP_CONF_IPV6 */
+ /* IPv4 header. */
+
+ u8_t vhl, tos, len[2], ipid[2], ipoffset[2], ttl, proto;
+ u16_t ipchksum;
+ u16_t srcipaddr[2], destipaddr[2];
+ #endif /* UIP_CONF_IPV6 */
+
+ /* TCP header. */
+
+ u16_t srcport, destport;
+ u8_t seqno[4], ackno[4], tcpoffset, flags, wnd[2];
+ u16_t tcpchksum;
+ u8_t urgp[2];
+ u8_t optdata[4];
+};
+
+/* The ICMP and IP headers. */
+struct uip_icmpip_hdr
+{
+ #if UIP_CONF_IPV6
+ /* IPv6 header. */
+ u8_t vtc, tcf;
+ u16_t flow;
+ u8_t len[2];
+ u8_t proto, ttl;
+ uip_ip6addr_t srcipaddr, destipaddr;
+ #else /* UIP_CONF_IPV6 */
+ /* IPv4 header. */
+
+ u8_t vhl, tos, len[2], ipid[2], ipoffset[2], ttl, proto;
+ u16_t ipchksum;
+ u16_t srcipaddr[2], destipaddr[2];
+ #endif /* UIP_CONF_IPV6 */
+
+ /* ICMP (echo) header. */
+
+ u8_t type, icode;
+ u16_t icmpchksum;
+ #if !UIP_CONF_IPV6
+ u16_t id, seqno;
+ #else /* !UIP_CONF_IPV6 */
+ u8_t flags, reserved1, reserved2, reserved3;
+ u8_t icmp6data[16];
+ u8_t options[1];
+ #endif /* !UIP_CONF_IPV6 */
+};
+
+/* The UDP and IP headers. */
+struct uip_udpip_hdr
+{
+ #if UIP_CONF_IPV6
+ /* IPv6 header. */
+ u8_t vtc, tcf;
+ u16_t flow;
+ u8_t len[2];
+ u8_t proto, ttl;
+ uip_ip6addr_t srcipaddr, destipaddr;
+ #else /* UIP_CONF_IPV6 */
+ /* IP header. */
+
+ u8_t vhl, tos, len[2], ipid[2], ipoffset[2], ttl, proto;
+ u16_t ipchksum;
+ u16_t srcipaddr[2], destipaddr[2];
+ #endif /* UIP_CONF_IPV6 */
+
+ /* UDP header. */
+
+ u16_t srcport, destport;
+ u16_t udplen;
+ u16_t udpchksum;
+};
+
+/**
+ * The buffer size available for user data in the \ref uip_buf buffer.
+ *
+ * This macro holds the available size for user data in the \ref
+ * uip_buf buffer. The macro is intended to be used for checking
+ * bounds of available user data.
+ *
+ * Example:
+ \code
+ snprintf(uip_appdata, UIP_APPDATA_SIZE, "%u\n", i);
+ \endcode
+ *
+ * \hideinitializer
+ */
+ #define UIP_APPDATA_SIZE (UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN)
+ #define UIP_PROTO_ICMP 1
+ #define UIP_PROTO_TCP 6
+ #define UIP_PROTO_UDP 17
+ #define UIP_PROTO_ICMP6 58
+
+/* Header sizes. */
+
+ #if UIP_CONF_IPV6
+ #define UIP_IPH_LEN 40
+ #else /* UIP_CONF_IPV6 */
+
+ #define UIP_IPH_LEN 20 /* Size of IP header */
+ #endif /* UIP_CONF_IPV6 */
+
+ #define UIP_UDPH_LEN 8 /* Size of UDP header */
+
+ #define UIP_TCPH_LEN 20 /* Size of TCP header */
+
+ #define UIP_IPUDPH_LEN (UIP_UDPH_LEN + UIP_IPH_LEN) /* Size of IP +
+ UDP
+ header */
+
+ #define UIP_IPTCPH_LEN (UIP_TCPH_LEN + UIP_IPH_LEN) /* Size of IP +
+ TCP
+ header */
+
+ #define UIP_TCPIP_HLEN UIP_IPTCPH_LEN
+
+ #if UIP_FIXEDADDR
+extern const uip_ipaddr_t uip_hostaddr, uip_netmask, uip_draddr;
+ #else /* UIP_FIXEDADDR */
+
+extern uip_ipaddr_t uip_hostaddr, uip_netmask, uip_draddr;
+ #endif /* UIP_FIXEDADDR */
+
+/**
+ * Representation of a 48-bit Ethernet address.
+ */
+
+struct uip_eth_addr
+{
+ u8_t addr[6];
+};
+
+/**
+ * Calculate the Internet checksum over a buffer.
+ *
+ * The Internet checksum is the one's complement of the one's
+ * complement sum of all 16-bit words in the buffer.
+ *
+ * See RFC1071.
+ *
+ * \param buf A pointer to the buffer over which the checksum is to be
+ * computed.
+ *
+ * \param len The length of the buffer over which the checksum is to
+ * be computed.
+ *
+ * \return The Internet checksum of the buffer.
+ */
+u16_t uip_chksum(u16_t* buf, u16_t len);
+
+/**
+ * Calculate the IP header checksum of the packet header in uip_buf.
+ *
+ * The IP header checksum is the Internet checksum of the 20 bytes of
+ * the IP header.
+ *
+ * \return The IP header checksum of the IP header in the uip_buf
+ * buffer.
+ */
+u16_t uip_ipchksum(void);
+
+/**
+ * Calculate the TCP checksum of the packet in uip_buf and uip_appdata.
+ *
+ * The TCP checksum is the Internet checksum of data contents of the
+ * TCP segment, and a pseudo-header as defined in RFC793.
+ *
+ * \return The TCP checksum of the TCP segment in uip_buf and pointed
+ * to by uip_appdata.
+ */
+u16_t uip_tcpchksum(void);
+
+/**
+ * Calculate the UDP checksum of the packet in uip_buf and uip_appdata.
+ *
+ * The UDP checksum is the Internet checksum of data contents of the
+ * UDP segment, and a pseudo-header as defined in RFC768.
+ *
+ * \return The UDP checksum of the UDP segment in uip_buf and pointed
+ * to by uip_appdata.
+ */
+u16_t uip_udpchksum(void);
+#endif /* __UIP_H__ */
+
+/** @} */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/uip_arch.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,134 @@
+/**
+ * \addtogroup uip
+ * {@
+ */
+/**
+ * \defgroup uiparch Architecture specific uIP functions
+ * @{
+ *
+ * The functions in the architecture specific module implement the IP
+ * check sum and 32-bit additions.
+ *
+ * The IP checksum calculation is the most computationally expensive
+ * operation in the TCP/IP stack and it therefore pays off to
+ * implement this in efficient assembler. The purpose of the uip-arch
+ * module is to let the checksum functions to be implemented in
+ * architecture specific assembler.
+ *
+ */
+/**
+ * \file
+ * Declarations of architecture specific functions.
+ * \author Adam Dunkels <adam@dunkels.com>
+ */
+/*
+ * Copyright (c) 2001, Adam Dunkels.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack.
+ *
+ * $Id: uip_arch.h,v 1.2 2006/06/07 09:15:19 adam Exp $
+ *
+ */
+#ifndef __UIP_ARCH_H__
+ #define __UIP_ARCH_H__
+
+ #include "uip.h"
+
+/**
+ * Carry out a 32-bit addition.
+ *
+ * Because not all architectures for which uIP is intended has native
+ * 32-bit arithmetic, uIP uses an external C function for doing the
+ * required 32-bit additions in the TCP protocol processing. This
+ * function should add the two arguments and place the result in the
+ * global variable uip_acc32.
+ *
+ * \note The 32-bit integer pointed to by the op32 parameter and the
+ * result in the uip_acc32 variable are in network byte order (big
+ * endian).
+ *
+ * \param op32 A pointer to a 4-byte array representing a 32-bit
+ * integer in network byte order (big endian).
+ *
+ * \param op16 A 16-bit integer in host byte order.
+ */
+void uip_add32(u8_t* op32, u16_t op16);
+
+/**
+ * Calculate the Internet checksum over a buffer.
+ *
+ * The Internet checksum is the one's complement of the one's
+ * complement sum of all 16-bit words in the buffer.
+ *
+ * See RFC1071.
+ *
+ * \note This function is not called in the current version of uIP,
+ * but future versions might make use of it.
+ *
+ * \param buf A pointer to the buffer over which the checksum is to be
+ * computed.
+ *
+ * \param len The length of the buffer over which the checksum is to
+ * be computed.
+ *
+ * \return The Internet checksum of the buffer.
+ */
+u16_t uip_chksum(u16_t* buf, u16_t len);
+
+/**
+ * Calculate the IP header checksum of the packet header in uip_buf.
+ *
+ * The IP header checksum is the Internet checksum of the 20 bytes of
+ * the IP header.
+ *
+ * \return The IP header checksum of the IP header in the uip_buf
+ * buffer.
+ */
+u16_t uip_ipchksum(void);
+
+/**
+ * Calculate the TCP checksum of the packet in uip_buf and uip_appdata.
+ *
+ * The TCP checksum is the Internet checksum of data contents of the
+ * TCP segment, and a pseudo-header as defined in RFC793.
+ *
+ * \note The uip_appdata pointer that points to the packet data may
+ * point anywhere in memory, so it is not possible to simply calculate
+ * the Internet checksum of the contents of the uip_buf buffer.
+ *
+ * \return The TCP checksum of the TCP segment in uip_buf and pointed
+ * to by uip_appdata.
+ */
+u16_t uip_tcpchksum(void);
+
+u16_t uip_udpchksum(void);
+
+/** @} */
+
+/** @} */
+#endif /* __UIP_ARCH_H__ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/uip_arp.c Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,417 @@
+/**
+ * \addtogroup uip
+ * @{
+ */
+/**
+ * \defgroup uiparp uIP Address Resolution Protocol
+ * @{
+ *
+ * The Address Resolution Protocol ARP is used for mapping between IP
+ * addresses and link level addresses such as the Ethernet MAC
+ * addresses. ARP uses broadcast queries to ask for the link level
+ * address of a known IP address and the host which is configured with
+ * the IP address for which the query was meant, will respond with its
+ * link level address.
+ *
+ * \note This ARP implementation only supports Ethernet.
+ */
+/**
+ * \file
+ * Implementation of the ARP Address Resolution Protocol.
+ * \author Adam Dunkels <adam@dunkels.com>
+ *
+ */
+/*
+ * Copyright (c) 2001-2003, Adam Dunkels.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack.
+ *
+ * $Id: uip_arp.c,v 1.8 2006/06/02 23:36:21 adam Exp $
+ *
+ */
+#include "uip_arp.h"
+
+#include <string.h>
+
+struct arp_hdr
+{
+ struct uip_eth_hdr ethhdr;
+ u16_t hwtype;
+ u16_t protocol;
+ u8_t hwlen;
+ u8_t protolen;
+ u16_t opcode;
+ struct uip_eth_addr shwaddr;
+ u16_t sipaddr[2];
+ struct uip_eth_addr dhwaddr;
+ u16_t dipaddr[2];
+};
+
+struct ethip_hdr
+{
+ struct uip_eth_hdr ethhdr;
+
+ /* IP header. */
+ u8_t vhl, tos, len[2], ipid[2], ipoffset[2], ttl, proto;
+ u16_t ipchksum;
+ u16_t srcipaddr[2], destipaddr[2];
+};
+
+#define ARP_REQUEST 1
+#define ARP_REPLY 2
+
+#define ARP_HWTYPE_ETH 1
+
+struct arp_entry
+{
+ u16_t ipaddr[2];
+ struct uip_eth_addr ethaddr;
+ u8_t time;
+};
+
+static const struct uip_eth_addr broadcast_ethaddr = { { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } };
+static const u16_t broadcast_ipaddr[2] = { 0xffff, 0xffff };
+
+static struct arp_entry arp_table[UIP_ARPTAB_SIZE];
+static u16_t ipaddr[2];
+static u8_t i, c;
+
+static u8_t arptime;
+static u8_t tmpage;
+
+#define BUF ((struct arp_hdr*) &uip_buf[0])
+#define IPBUF ((struct ethip_hdr*) &uip_buf[0])
+/*-----------------------------------------------------------------------------------*/
+
+/**
+ * Initialize the ARP module.
+ *
+ */
+
+/*-----------------------------------------------------------------------------------*/
+void uip_arp_init(void) {
+ for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
+ memset(arp_table[i].ipaddr, 0, 4);
+ }
+}
+
+/*-----------------------------------------------------------------------------------*/
+/**
+ * Periodic ARP processing function.
+ *
+ * This function performs periodic timer processing in the ARP module
+ * and should be called at regular intervals. The recommended interval
+ * is 10 seconds between the calls.
+ *
+ */
+
+/*-----------------------------------------------------------------------------------*/
+void uip_arp_timer(void) {
+ struct arp_entry* tabptr;
+
+ ++arptime;
+ for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
+ tabptr = &arp_table[i];
+ if((tabptr->ipaddr[0] | tabptr->ipaddr[1]) != 0 && arptime - tabptr->time >= UIP_ARP_MAXAGE) {
+ memset(tabptr->ipaddr, 0, 4);
+ }
+ }
+}
+
+/*-----------------------------------------------------------------------------------*/
+static void uip_arp_update(u16_t* ipaddr, struct uip_eth_addr* ethaddr) {
+ register struct arp_entry* tabptr;
+ /* Walk through the ARP mapping table and try to find an entry to
+ update. If none is found, the IP -> MAC address mapping is
+ inserted in the ARP table. */
+
+ for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
+ tabptr = &arp_table[i];
+
+ /* Only check those entries that are actually in use. */
+ if(tabptr->ipaddr[0] != 0 && tabptr->ipaddr[1] != 0) {
+
+ /* Check if the source IP address of the incoming packet matches
+ the IP address in this ARP table entry. */
+ if(ipaddr[0] == tabptr->ipaddr[0] && ipaddr[1] == tabptr->ipaddr[1]) {
+
+ /* An old entry found, update this and return. */
+ memcpy(tabptr->ethaddr.addr, ethaddr->addr, 6);
+ tabptr->time = arptime;
+
+ return;
+ }
+ }
+ }
+
+ /* If we get here, no existing ARP table entry was found, so we
+ create one. */
+ /* First, we try to find an unused entry in the ARP table. */
+ for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
+ tabptr = &arp_table[i];
+ if(tabptr->ipaddr[0] == 0 && tabptr->ipaddr[1] == 0) {
+ break;
+ }
+ }
+
+ /* If no unused entry is found, we try to find the oldest entry and
+ throw it away. */
+ if(i == UIP_ARPTAB_SIZE) {
+ tmpage = 0;
+ c = 0;
+ for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
+ tabptr = &arp_table[i];
+ if(arptime - tabptr->time > tmpage) {
+ tmpage = arptime - tabptr->time;
+ c = i;
+ }
+ }
+
+ i = c;
+ tabptr = &arp_table[i];
+ }
+
+ /* Now, i is the ARP table entry which we will fill with the new
+ information. */
+ memcpy(tabptr->ipaddr, ipaddr, 4);
+ memcpy(tabptr->ethaddr.addr, ethaddr->addr, 6);
+ tabptr->time = arptime;
+}
+
+/*-----------------------------------------------------------------------------------*/
+/**
+ * ARP processing for incoming IP packets
+ *
+ * This function should be called by the device driver when an IP
+ * packet has been received. The function will check if the address is
+ * in the ARP cache, and if so the ARP cache entry will be
+ * refreshed. If no ARP cache entry was found, a new one is created.
+ *
+ * This function expects an IP packet with a prepended Ethernet header
+ * in the uip_buf[] buffer, and the length of the packet in the global
+ * variable uip_len.
+ */
+/*-----------------------------------------------------------------------------------*/
+
+//#if 0
+void uip_arp_ipin(void) {
+ uip_len -= sizeof(struct uip_eth_hdr);
+
+ /* Only insert/update an entry if the source IP address of the
+ incoming IP packet comes from a host on the local network. */
+ if((IPBUF->srcipaddr[0] & uip_netmask[0]) != (uip_hostaddr[0] & uip_netmask[0])) {
+ return;
+ }
+
+ if((IPBUF->srcipaddr[1] & uip_netmask[1]) != (uip_hostaddr[1] & uip_netmask[1])) {
+ return;
+ }
+
+ uip_arp_update(IPBUF->srcipaddr, &(IPBUF->ethhdr.src));
+
+ return;
+}
+
+//#endif /* 0 */
+/*-----------------------------------------------------------------------------------*/
+/**
+ * ARP processing for incoming ARP packets.
+ *
+ * This function should be called by the device driver when an ARP
+ * packet has been received. The function will act differently
+ * depending on the ARP packet type: if it is a reply for a request
+ * that we previously sent out, the ARP cache will be filled in with
+ * the values from the ARP reply. If the incoming ARP packet is an ARP
+ * request for our IP address, an ARP reply packet is created and put
+ * into the uip_buf[] buffer.
+ *
+ * When the function returns, the value of the global variable uip_len
+ * indicates whether the device driver should send out a packet or
+ * not. If uip_len is zero, no packet should be sent. If uip_len is
+ * non-zero, it contains the length of the outbound packet that is
+ * present in the uip_buf[] buffer.
+ *
+ * This function expects an ARP packet with a prepended Ethernet
+ * header in the uip_buf[] buffer, and the length of the packet in the
+ * global variable uip_len.
+ */
+
+/*-----------------------------------------------------------------------------------*/
+void uip_arp_arpin(void) {
+ if(uip_len < sizeof(struct arp_hdr)) {
+ uip_len = 0;
+ return;
+ }
+
+ uip_len = 0;
+
+ switch(BUF->opcode) {
+ case HTONS(ARP_REQUEST):
+ /* ARP request. If it asked for our address, we send out a
+ reply. */
+ if(uip_ipaddr_cmp(BUF->dipaddr, uip_hostaddr)) {
+
+ /* First, we register the one who made the request in our ARP
+ table, since it is likely that we will do more communication
+ with this host in the future. */
+ uip_arp_update(BUF->sipaddr, &BUF->shwaddr);
+
+ /* The reply opcode is 2. */
+ BUF->opcode = HTONS(2);
+
+ memcpy(BUF->dhwaddr.addr, BUF->shwaddr.addr, 6);
+ memcpy(BUF->shwaddr.addr, uip_ethaddr.addr, 6);
+ memcpy(BUF->ethhdr.src.addr, uip_ethaddr.addr, 6);
+ memcpy(BUF->ethhdr.dest.addr, BUF->dhwaddr.addr, 6);
+
+ BUF->dipaddr[0] = BUF->sipaddr[0];
+ BUF->dipaddr[1] = BUF->sipaddr[1];
+ BUF->sipaddr[0] = uip_hostaddr[0];
+ BUF->sipaddr[1] = uip_hostaddr[1];
+
+ BUF->ethhdr.type = HTONS(UIP_ETHTYPE_ARP);
+ uip_len = sizeof(struct arp_hdr);
+ }
+ break;
+
+ case HTONS(ARP_REPLY):
+ /* ARP reply. We insert or update the ARP table if it was meant
+ for us. */
+ if(uip_ipaddr_cmp(BUF->dipaddr, uip_hostaddr)) {
+ uip_arp_update(BUF->sipaddr, &BUF->shwaddr);
+ }
+ break;
+ }
+
+ return;
+}
+
+/*-----------------------------------------------------------------------------------*/
+/**
+ * Prepend Ethernet header to an outbound IP packet and see if we need
+ * to send out an ARP request.
+ *
+ * This function should be called before sending out an IP packet. The
+ * function checks the destination IP address of the IP packet to see
+ * what Ethernet MAC address that should be used as a destination MAC
+ * address on the Ethernet.
+ *
+ * If the destination IP address is in the local network (determined
+ * by logical ANDing of netmask and our IP address), the function
+ * checks the ARP cache to see if an entry for the destination IP
+ * address is found. If so, an Ethernet header is prepended and the
+ * function returns. If no ARP cache entry is found for the
+ * destination IP address, the packet in the uip_buf[] is replaced by
+ * an ARP request packet for the IP address. The IP packet is dropped
+ * and it is assumed that they higher level protocols (e.g., TCP)
+ * eventually will retransmit the dropped packet.
+ *
+ * If the destination IP address is not on the local network, the IP
+ * address of the default router is used instead.
+ *
+ * When the function returns, a packet is present in the uip_buf[]
+ * buffer, and the length of the packet is in the global variable
+ * uip_len.
+ */
+
+/*-----------------------------------------------------------------------------------*/
+void uip_arp_out(void) {
+ struct arp_entry* tabptr;
+
+ /* Find the destination IP address in the ARP table and construct
+ the Ethernet header. If the destination IP addres isn't on the
+ local network, we use the default router's IP address instead.
+
+ If not ARP table entry is found, we overwrite the original IP
+ packet with an ARP request for the IP address. */
+
+ /* First check if destination is a local broadcast. */
+ if(uip_ipaddr_cmp(IPBUF->destipaddr, broadcast_ipaddr)) {
+ memcpy(IPBUF->ethhdr.dest.addr, broadcast_ethaddr.addr, 6);
+ }
+ else {
+
+ /* Check if the destination address is on the local network. */
+ if(!uip_ipaddr_maskcmp(IPBUF->destipaddr, uip_hostaddr, uip_netmask)) {
+
+ /* Destination address was not on the local network, so we need to
+ use the default router's IP address instead of the destination
+ address when determining the MAC address. */
+ uip_ipaddr_copy(ipaddr, uip_draddr);
+ }
+ else {
+
+ /* Else, we use the destination IP address. */
+ uip_ipaddr_copy(ipaddr, IPBUF->destipaddr);
+ }
+
+ for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
+ tabptr = &arp_table[i];
+ if(uip_ipaddr_cmp(ipaddr, tabptr->ipaddr)) {
+ break;
+ }
+ }
+
+ if(i == UIP_ARPTAB_SIZE) {
+
+ /* The destination address was not in our ARP table, so we
+ overwrite the IP packet with an ARP request. */
+ memset(BUF->ethhdr.dest.addr, 0xff, 6);
+ memset(BUF->dhwaddr.addr, 0x00, 6);
+ memcpy(BUF->ethhdr.src.addr, uip_ethaddr.addr, 6);
+ memcpy(BUF->shwaddr.addr, uip_ethaddr.addr, 6);
+
+ uip_ipaddr_copy(BUF->dipaddr, ipaddr);
+ uip_ipaddr_copy(BUF->sipaddr, uip_hostaddr);
+ BUF->opcode = HTONS(ARP_REQUEST); /* ARP request. */
+ BUF->hwtype = HTONS(ARP_HWTYPE_ETH);
+ BUF->protocol = HTONS(UIP_ETHTYPE_IP);
+ BUF->hwlen = 6;
+ BUF->protolen = 4;
+ BUF->ethhdr.type = HTONS(UIP_ETHTYPE_ARP);
+
+ uip_appdata = &uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN];
+
+ uip_len = sizeof(struct arp_hdr);
+ return;
+ }
+
+ /* Build an ethernet header. */
+ memcpy(IPBUF->ethhdr.dest.addr, tabptr->ethaddr.addr, 6);
+ }
+
+ memcpy(IPBUF->ethhdr.src.addr, uip_ethaddr.addr, 6);
+
+ IPBUF->ethhdr.type = HTONS(UIP_ETHTYPE_IP);
+
+ uip_len += sizeof(struct uip_eth_hdr);
+}
+
+/*-----------------------------------------------------------------------------------*/
+/** @} */
+/** @} */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/uip_arp.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,142 @@
+/**
+ * \addtogroup uip
+ * @{
+ */
+/**
+ * \addtogroup uiparp
+ * @{
+ */
+/**
+ * \file
+ * Macros and definitions for the ARP module.
+ * \author Adam Dunkels <adam@dunkels.com>
+ */
+/*
+ * Copyright (c) 2001-2003, Adam Dunkels.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack.
+ *
+ * $Id: uip_arp.h,v 1.5 2006/06/11 21:46:39 adam Exp $
+ *
+ */
+#ifndef __UIP_ARP_H__
+ #define __UIP_ARP_H__
+
+ #include "uip.h"
+
+extern struct uip_eth_addr uip_ethaddr;
+
+/**
+ * The Ethernet header.
+ */
+struct uip_eth_hdr
+{
+ struct uip_eth_addr dest;
+ struct uip_eth_addr src;
+ u16_t type;
+};
+
+ #define UIP_ETHTYPE_ARP 0x0806
+ #define UIP_ETHTYPE_IP 0x0800
+ #define UIP_ETHTYPE_IP6 0x86dd
+
+/* The uip_arp_init() function must be called before any of the other
+ ARP functions. */
+void uip_arp_init(void);
+
+/* The uip_arp_ipin() function should be called whenever an IP packet
+ arrives from the Ethernet. This function refreshes the ARP table or
+ inserts a new mapping if none exists. The function assumes that an
+ IP packet with an Ethernet header is present in the uip_buf buffer
+ and that the length of the packet is in the uip_len variable. */
+void uip_arp_ipin(void);
+
+//#define uip_arp_ipin()
+/* The uip_arp_arpin() should be called when an ARP packet is received
+ by the Ethernet driver. This function also assumes that the
+ Ethernet frame is present in the uip_buf buffer. When the
+ uip_arp_arpin() function returns, the contents of the uip_buf
+ buffer should be sent out on the Ethernet if the uip_len variable
+ is > 0. */
+void uip_arp_arpin(void);
+
+/* The uip_arp_out() function should be called when an IP packet
+ should be sent out on the Ethernet. This function creates an
+ Ethernet header before the IP header in the uip_buf buffer. The
+ Ethernet header will have the correct Ethernet MAC destination
+ address filled in if an ARP table entry for the destination IP
+ address (or the IP address of the default router) is present. If no
+ such table entry is found, the IP packet is overwritten with an ARP
+ request and we rely on TCP to retransmit the packet that was
+ overwritten. In any case, the uip_len variable holds the length of
+ the Ethernet frame that should be transmitted. */
+void uip_arp_out(void);
+
+/* The uip_arp_timer() function should be called every ten seconds. It
+ is responsible for flushing old entries in the ARP table. */
+void uip_arp_timer(void);
+
+/** @} */
+
+/**
+ * \addtogroup uipconffunc
+ * @{
+ */
+
+/**
+ * Specifiy the Ethernet MAC address.
+ *
+ * The ARP code needs to know the MAC address of the Ethernet card in
+ * order to be able to respond to ARP queries and to generate working
+ * Ethernet headers.
+ *
+ * \note This macro only specifies the Ethernet MAC address to the ARP
+ * code. It cannot be used to change the MAC address of the Ethernet
+ * card.
+ *
+ * \param eaddr A pointer to a struct uip_eth_addr containing the
+ * Ethernet MAC address of the Ethernet card.
+ *
+ * \hideinitializer
+ */
+ #define uip_setethaddr(eaddr) \
+ do \
+ { \
+ uip_ethaddr.addr[0] = eaddr.addr[0]; \
+ uip_ethaddr.addr[1] = eaddr.addr[1]; \
+ uip_ethaddr.addr[2] = eaddr.addr[2]; \
+ uip_ethaddr.addr[3] = eaddr.addr[3]; \
+ uip_ethaddr.addr[4] = eaddr.addr[4]; \
+ uip_ethaddr.addr[5] = eaddr.addr[5]; \
+ } while(0)
+
+ /** @} */
+
+ /** @} */
+#endif /* __UIP_ARP_H__ */
+
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/uip_clock.cpp Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,12 @@
+#include <time.h>
+#include "uip_clock.h"
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+clock_time_t clock_time(void) {
+ return(clock_time_t) time(NULL);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/uip_clock.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,87 @@
+/**
+ * \defgroup clock Clock interface
+ *
+ * The clock interface is the interface between the \ref timer "timer library"
+ * and the platform specific clock functionality. The clock
+ * interface must be implemented for each platform that uses the \ref
+ * timer "timer library".
+ *
+ * The clock interface does only one this: it measures time. The clock
+ * interface provides a macro, CLOCK_SECOND, which corresponds to one
+ * second of system time.
+ *
+ * \sa \ref timer "Timer library"
+ *
+ * @{
+ */
+/*
+ * Copyright (c) 2004, Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the Institute nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack
+ *
+ * Author: Adam Dunkels <adam@sics.se>
+ *
+ * $Id: clock.h,v 1.3 2006/06/11 21:46:39 adam Exp $
+ */
+#ifndef __UIP_CLOCK_H__
+ #define __UIP_CLOCK_H__
+
+ #include "clock-arch.h"
+
+/**
+ * Initialize the clock library.
+ *
+ * This function initializes the clock library and should be called
+ * from the main() function of the system.
+ *
+ */
+void uip_clock_init(void);
+
+/**
+ * Get the current clock time.
+ *
+ * This function returns the current system clock time.
+ *
+ * \return The current clock time, measured in system ticks.
+ */
+clock_time_t clock_time(void);
+
+/**
+ * A second, measured in system clock time.
+ *
+ * \hideinitializer
+ */
+
+ #ifdef CLOCK_CONF_SECOND
+ #define CLOCK_SECOND CLOCK_CONF_SECOND
+ #else
+ #define CLOCK_SECOND (clock_time_t) 32
+ #endif
+#endif /* __CLOCK_H__ */
+
+/** @} */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/uip_debug.cpp Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,180 @@
+#if defined(UIPDEBUG)
+ #include <mbed.h>
+ #include <inttypes.h>
+ #include <uip_debug.h>
+extern "C"
+{
+ #include "uip.h"
+} extern Serial pc;
+struct uip_conn con[UIP_CONNS];
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPDebug::uip_debug_printconns(void) {
+ for(uint8_t i = 0; i < UIP_CONNS; i++) {
+ if(uip_debug_printcon(&con[i], &uip_conns[i])) {
+ pc.printf("connection[");
+ pc.printf("%d", i);
+ pc.printf("] changed.\n");
+ }
+ }
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+bool UIPDebug::uip_debug_printcon(struct uip_conn* lhs, struct uip_conn* rhs) {
+ bool changed = false;
+ if(!uip_ipaddr_cmp(lhs->ripaddr, rhs->ripaddr)) {
+ pc.printf(" ripaddr: ");
+ uip_debug_printbytes((const uint8_t*)lhs->ripaddr, 4);
+ pc.printf(" -> ");
+ uip_debug_printbytes((const uint8_t*)rhs->ripaddr, 4);
+ pc.printf("\n");
+ uip_ipaddr_copy(lhs->ripaddr, rhs->ripaddr);
+ changed = true;
+ }
+
+ if(lhs->lport != rhs->lport) {
+ pc.printf(" lport: ");
+ pc.printf("%d", htons(lhs->lport));
+ pc.printf(" -> ");
+ pc.printf("%d\n", htons(rhs->lport));
+ lhs->lport = rhs->lport;
+ changed = true;
+ }
+
+ if(lhs->rport != rhs->rport) {
+ pc.printf(" rport: ");
+ pc.printf("%d", htons(lhs->rport));
+ pc.printf(" -> ");
+ pc.printf("%d\n", htons(rhs->rport));
+ lhs->rport = rhs->rport;
+ changed = true;
+ }
+
+ if((uint32_t) lhs->rcv_nxt[0] != (uint32_t) rhs->rcv_nxt[0]) {
+ pc.printf(" rcv_nxt: ");
+ uip_debug_printbytes(lhs->rcv_nxt, 4);
+ pc.printf(" -> ");
+ uip_debug_printbytes(rhs->rcv_nxt, 4);
+ *((uint32_t*) &lhs->rcv_nxt[0]) = (uint32_t) rhs->rcv_nxt[0];
+ pc.printf("\n");
+ changed = true;
+ }
+
+ if((uint32_t) lhs->snd_nxt[0] != (uint32_t) rhs->snd_nxt[0]) {
+ pc.printf(" snd_nxt: ");
+ uip_debug_printbytes(lhs->snd_nxt, 4);
+ pc.printf(" -> ");
+ uip_debug_printbytes(rhs->snd_nxt, 4);
+ *((uint32_t*) &lhs->snd_nxt[0]) = (uint32_t) rhs->snd_nxt[0];
+ pc.printf("\n");
+ changed = true;
+ }
+
+ if(lhs->len != rhs->len) {
+ pc.printf(" len: ");
+ pc.printf("%d", lhs->len);
+ pc.printf(" -> ");
+ pc.printf("%d\n", rhs->len);
+ lhs->len = rhs->len;
+ changed = true;
+ }
+
+ if(lhs->mss != rhs->mss) {
+ pc.printf(" mss: ");
+ pc.printf("%d", lhs->mss);
+ pc.printf(" -> ");
+ pc.printf("%d\n", rhs->mss);
+ lhs->mss = rhs->mss;
+ changed = true;
+ }
+
+ if(lhs->initialmss != rhs->initialmss) {
+ pc.printf(" initialmss: ");
+ pc.printf("%d", lhs->initialmss);
+ pc.printf(" -> ");
+ pc.printf("%d\n", rhs->initialmss);
+ lhs->initialmss = rhs->initialmss;
+ changed = true;
+ }
+
+ if(lhs->sa != rhs->sa) {
+ pc.printf(" sa: ");
+ pc.printf("%d", lhs->sa);
+ pc.printf(" -> ");
+ pc.printf("%d", rhs->sa);
+ lhs->sa = rhs->sa;
+ changed = true;
+ }
+
+ if(lhs->sv != rhs->sv) {
+ pc.printf(" sv: ");
+ pc.printf("%d", lhs->sv);
+ pc.printf(" -> ");
+ pc.printf("%d\n", rhs->sv);
+ lhs->sv = rhs->sv;
+ changed = true;
+ }
+
+ if(lhs->rto != rhs->rto) {
+ pc.printf(" rto: ");
+ pc.printf("%d", lhs->rto);
+ pc.printf(" -> ");
+ pc.printf("%d\n", rhs->rto);
+ lhs->rto = rhs->rto;
+ changed = true;
+ }
+
+ if(lhs->tcpstateflags != rhs->tcpstateflags) {
+ pc.printf(" tcpstateflags: ");
+ pc.printf("%d", lhs->tcpstateflags);
+ pc.printf(" -> ");
+ pc.printf("%d\n", rhs->tcpstateflags);
+ lhs->tcpstateflags = rhs->tcpstateflags;
+ changed = true;
+ }
+
+ if(lhs->timer != rhs->timer) {
+ pc.printf(" timer: ");
+ pc.printf("%d", lhs->timer);
+ pc.printf(" -> ");
+ pc.printf("%d\n", rhs->timer);
+ lhs->timer = rhs->timer;
+ changed = true;
+ }
+
+ if(lhs->nrtx != rhs->nrtx) {
+ pc.printf(" nrtx: ");
+ pc.printf("%d", lhs->nrtx);
+ pc.printf(" -> ");
+ pc.printf("%d\n", rhs->nrtx);
+ lhs->nrtx = rhs->nrtx;
+ changed = true;
+ }
+
+ return changed;
+}
+
+/**
+ * @brief
+ * @note
+ * @param
+ * @retval
+ */
+void UIPDebug::uip_debug_printbytes(const uint8_t* data, uint8_t len) {
+ for(uint8_t i = 0; i < len; i++) {
+ pc.printf("%d", data[i]);
+ if(i < len - 1)
+ pc.printf(",");
+ }
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/uip_debug.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,14 @@
+#ifndef UIP_DEBUG_H
+ #define UIP_DEBUG_H
+extern "C"
+{
+ #include "uip.h"
+}
+class UIPDebug
+{
+public:
+ static void uip_debug_printconns(void);
+ static bool uip_debug_printcon(struct uip_conn* lhs, struct uip_conn* rhs);
+ static void uip_debug_printbytes(const uint8_t* data, uint8_t len);
+};
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/uip_timer.c Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,123 @@
+/**
+ * \addtogroup timer
+ * @{
+ */
+/**
+ * \file
+ * Timer library implementation.
+ * \author
+ * Adam Dunkels <adam@sics.se>
+ */
+/*
+ * Copyright (c) 2004, Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the Institute nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack
+ *
+ * Author: Adam Dunkels <adam@sics.se>
+ *
+ * $Id: timer.c,v 1.2 2006/06/12 08:00:30 adam Exp $
+ */
+#include "uip_clock.h"
+#include "uip_timer.h"
+
+/*---------------------------------------------------------------------------*/
+
+/**
+ * Set a timer.
+ *
+ * This function is used to set a timer for a time sometime in the
+ * future. The function timer_expired() will evaluate to true after
+ * the timer has expired.
+ *
+ * \param t A pointer to the timer
+ * \param interval The interval before the timer expires.
+ *
+ */
+void uip_timer_set(struct uip_timer* t, clock_time_t interval) {
+ t->interval = interval;
+ t->start = clock_time();
+}
+
+/*---------------------------------------------------------------------------*/
+
+/**
+ * Reset the timer with the same interval.
+ *
+ * This function resets the timer with the same interval that was
+ * given to the timer_set() function. The start point of the interval
+ * is the exact time that the timer last expired. Therefore, this
+ * function will cause the timer to be stable over time, unlike the
+ * timer_rester() function.
+ *
+ * \param t A pointer to the timer.
+ *
+ * \sa timer_restart()
+ */
+void uip_timer_reset(struct uip_timer* t) {
+ t->start += t->interval;
+}
+
+/*---------------------------------------------------------------------------*/
+
+/**
+ * Restart the timer from the current point in time
+ *
+ * This function restarts a timer with the same interval that was
+ * given to the timer_set() function. The timer will start at the
+ * current time.
+ *
+ * \note A periodic timer will drift if this function is used to reset
+ * it. For preioric timers, use the timer_reset() function instead.
+ *
+ * \param t A pointer to the timer.
+ *
+ * \sa timer_reset()
+ */
+void uip_timer_restart(struct uip_timer* t) {
+ t->start = clock_time();
+}
+
+/*---------------------------------------------------------------------------*/
+
+/**
+ * Check if a timer has expired.
+ *
+ * This function tests if a timer has expired and returns true or
+ * false depending on its status.
+ *
+ * \param t A pointer to the timer
+ *
+ * \return Non-zero if the timer has expired, zero otherwise.
+ *
+ */
+int uip_timer_expired(struct uip_timer* t) {
+ return(clock_time_t) (clock_time() - t->start) >= (clock_time_t) t->interval;
+}
+
+/*---------------------------------------------------------------------------*/
+/** @} */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/uip_timer.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,83 @@
+/**
+ * \defgroup timer Timer library
+ *
+ * The timer library provides functions for setting, resetting and
+ * restarting timers, and for checking if a timer has expired. An
+ * application must "manually" check if its timers have expired; this
+ * is not done automatically.
+ *
+ * A timer is declared as a \c struct \c timer and all access to the
+ * timer is made by a pointer to the declared timer.
+ *
+ * \note The timer library uses the \ref clock "Clock library" to
+ * measure time. Intervals should be specified in the format used by
+ * the clock library.
+ *
+ * @{
+ */
+/**
+ * \file
+ * Timer library header file.
+ * \author
+ * Adam Dunkels <adam@sics.se>
+ */
+/*
+ * Copyright (c) 2004, Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the Institute nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack
+ *
+ * Author: Adam Dunkels <adam@sics.se>
+ *
+ * $Id: timer.h,v 1.3 2006/06/11 21:46:39 adam Exp $
+ */
+#ifndef __UIP_TIMER_H__
+ #define __UIP_TIMER_H__
+
+ #include "uip_clock.h"
+
+/**
+ * A timer.
+ *
+ * This structure is used for declaring a timer. The timer must be set
+ * with timer_set() before it can be used.
+ *
+ * \hideinitializer
+ */
+struct uip_timer
+{
+ clock_time_t start;
+ clock_time_t interval;
+};
+
+void uip_timer_set(struct uip_timer* t, clock_time_t interval);
+void uip_timer_reset(struct uip_timer* t);
+void uip_timer_restart(struct uip_timer* t);
+int uip_timer_expired(struct uip_timer* t);
+#endif /* __UIP_TIMER_H__ */
+
+/** @} */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uitility/uipethernet-conf.h Mon Sep 15 11:12:30 2014 +0000 @@ -0,0 +1,20 @@ +#ifndef UIPETHERNET_CONF_H + #define UIPETHERNET_CONF_H + +/* for TCP */ + + #define UIP_SOCKET_NUMPACKETS 5 + #define UIP_CONF_MAX_CONNECTIONS 4 + +/* for UDP */ + + #define UIP_CONF_UDP 1 + #define UIP_CONF_BROADCAST 1 + #define UIP_CONF_UDP_CONNS 4 + #define UIP_UDP_NUMPACKETS 5 + +/* number of attempts on write before returning number of bytes sent so far + * set to -1 to block until connection is closed by timeout */ + + #define UIP_ATTEMPTS_ON_WRITE - 1 +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitility/uipopt.h Mon Sep 15 11:12:30 2014 +0000
@@ -0,0 +1,555 @@
+/**
+ * \defgroup uipopt Configuration options for uIP
+ * @{
+ *
+ * uIP is configured using the per-project configuration file
+ * uipopt.h. This file contains all compile-time options for uIP and
+ * should be tweaked to match each specific project. The uIP
+ * distribution contains a documented example "uipopt.h" that can be
+ * copied and modified for each project.
+ *
+ * \note Most of the configuration options in the uipopt.h should not
+ * be changed, but rather the per-project uip-conf.h file.
+ */
+/**
+ * \file
+ * Configuration options for uIP.
+ * \author Adam Dunkels <adam@dunkels.com>
+ *
+ * This file is used for tweaking various configuration options for
+ * uIP. You should make a copy of this file into one of your project's
+ * directories instead of editing this example "uipopt.h" file that
+ * comes with the uIP distribution.
+ */
+/*
+ * Copyright (c) 2001-2003, Adam Dunkels.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This file is part of the uIP TCP/IP stack.
+ *
+ * $Id: uipopt.h,v 1.4 2006/06/12 08:00:31 adam Exp $
+ *
+ */
+#ifndef __UIPOPT_H__
+ #define __UIPOPT_H__
+
+ #ifndef UIP_LITTLE_ENDIAN
+ #define UIP_LITTLE_ENDIAN 3412
+ #endif /* UIP_LITTLE_ENDIAN */
+
+ #ifndef UIP_BIG_ENDIAN
+ #define UIP_BIG_ENDIAN 1234
+ #endif /* UIP_BIG_ENDIAN */
+
+ #include "uip-conf.h"
+
+/*------------------------------------------------------------------------------*/
+
+/**
+ * \name Static configuration options
+ * @{
+ *
+ * These configuration options can be used for setting the IP address
+ * settings statically, but only if UIP_FIXEDADDR is set to 1. The
+ * configuration options for a specific node includes IP address,
+ * netmask and default router as well as the Ethernet address. The
+ * netmask, default router and Ethernet address are appliciable only
+ * if uIP should be run over Ethernet.
+ *
+ * All of these should be changed to suit your project.
+*/
+/**
+ * Determines if uIP should use a fixed IP address or not.
+ *
+ * If uIP should use a fixed IP address, the settings are set in the
+ * uipopt.h file. If not, the macros uip_sethostaddr(),
+ * uip_setdraddr() and uip_setnetmask() should be used instead.
+ *
+ * \hideinitializer
+ */
+ #define UIP_FIXEDADDR 0
+
+/**
+ * Ping IP address asignment.
+ *
+ * uIP uses a "ping" packets for setting its own IP address if this
+ * option is set. If so, uIP will start with an empty IP address and
+ * the destination IP address of the first incoming "ping" (ICMP echo)
+ * packet will be used for setting the hosts IP address.
+ *
+ * \note This works only if UIP_FIXEDADDR is 0.
+ *
+ * \hideinitializer
+ */
+
+ #ifdef UIP_CONF_PINGADDRCONF
+ #define UIP_PINGADDRCONF UIP_CONF_PINGADDRCONF
+ #else /* UIP_CONF_PINGADDRCONF */
+
+ #define UIP_PINGADDRCONF 0
+ #endif /* UIP_CONF_PINGADDRCONF */
+
+/**
+ * Specifies if the uIP ARP module should be compiled with a fixed
+ * Ethernet MAC address or not.
+ *
+ * If this configuration option is 0, the macro uip_setethaddr() can
+ * be used to specify the Ethernet address at run-time.
+ *
+ * \hideinitializer
+ */
+
+ #define UIP_FIXEDETHADDR 0
+
+/** @} */
+
+/*------------------------------------------------------------------------------*/
+/**
+ * \name IP configuration options
+ * @{
+ *
+ */
+/**
+ * The IP TTL (time to live) of IP packets sent by uIP.
+ *
+ * This should normally not be changed.
+ */
+ #define UIP_TTL 64
+
+/**
+ * Turn on support for IP packet reassembly.
+ *
+ * uIP supports reassembly of fragmented IP packets. This features
+ * requires an additonal amount of RAM to hold the reassembly buffer
+ * and the reassembly code size is approximately 700 bytes. The
+ * reassembly buffer is of the same size as the uip_buf buffer
+ * (configured by UIP_BUFSIZE).
+ *
+ * \note IP packet reassembly is not heavily tested.
+ *
+ * \hideinitializer
+ */
+
+ #define UIP_REASSEMBLY 0
+
+/**
+ * The maximum time an IP fragment should wait in the reassembly
+ * buffer before it is dropped.
+ *
+ */
+
+ #define UIP_REASS_MAXAGE 40
+
+/** @} */
+
+/*------------------------------------------------------------------------------*/
+/**
+ * \name UDP configuration options
+ * @{
+ */
+/**
+ * Toggles wether UDP support should be compiled in or not.
+ *
+ * \hideinitializer
+ */
+ #ifdef UIP_CONF_UDP
+ #define UIP_UDP UIP_CONF_UDP
+ #else /* UIP_CONF_UDP */
+
+ #define UIP_UDP 0
+ #endif /* UIP_CONF_UDP */
+
+/**
+ * Toggles if UDP checksums should be used or not.
+ *
+ * \note Support for UDP checksums is currently not included in uIP,
+ * so this option has no function.
+ *
+ * \hideinitializer
+ */
+
+ #ifdef UIP_CONF_UDP_CHECKSUMS
+ #define UIP_UDP_CHECKSUMS UIP_CONF_UDP_CHECKSUMS
+ #else
+ #define UIP_UDP_CHECKSUMS 0
+ #endif
+/**
+ * The maximum amount of concurrent UDP connections.
+ *
+ * \hideinitializer
+ */
+
+ #ifdef UIP_CONF_UDP_CONNS
+ #define UIP_UDP_CONNS UIP_CONF_UDP_CONNS
+ #else /* UIP_CONF_UDP_CONNS */
+
+ #define UIP_UDP_CONNS 10
+ #endif /* UIP_CONF_UDP_CONNS */
+
+/**
+ * The name of the function that should be called when UDP datagrams arrive.
+ *
+ * \hideinitializer
+ */
+
+/** @} */
+/*------------------------------------------------------------------------------*/
+/**
+ * \name TCP configuration options
+ * @{
+ */
+/**
+ * Determines if support for opening connections from uIP should be
+ * compiled in.
+ *
+ * If the applications that are running on top of uIP for this project
+ * do not need to open outgoing TCP connections, this configration
+ * option can be turned off to reduce the code size of uIP.
+ *
+ * \hideinitializer
+ */
+ #define UIP_ACTIVE_OPEN 1
+
+/**
+ * The maximum number of simultaneously open TCP connections.
+ *
+ * Since the TCP connections are statically allocated, turning this
+ * configuration knob down results in less RAM used. Each TCP
+ * connection requires approximatly 30 bytes of memory.
+ *
+ * \hideinitializer
+ */
+
+ #ifndef UIP_CONF_MAX_CONNECTIONS
+ #define UIP_CONNS 10
+ #else /* UIP_CONF_MAX_CONNECTIONS */
+
+ #define UIP_CONNS UIP_CONF_MAX_CONNECTIONS
+ #endif /* UIP_CONF_MAX_CONNECTIONS */
+
+/**
+ * The maximum number of simultaneously listening TCP ports.
+ *
+ * Each listening TCP port requires 2 bytes of memory.
+ *
+ * \hideinitializer
+ */
+
+ #ifndef UIP_CONF_MAX_LISTENPORTS
+ #define UIP_LISTENPORTS 20
+ #else /* UIP_CONF_MAX_LISTENPORTS */
+
+ #define UIP_LISTENPORTS UIP_CONF_MAX_LISTENPORTS
+ #endif /* UIP_CONF_MAX_LISTENPORTS */
+
+/**
+ * Determines if support for TCP urgent data notification should be
+ * compiled in.
+ *
+ * Urgent data (out-of-band data) is a rarely used TCP feature that
+ * very seldom would be required.
+ *
+ * \hideinitializer
+ */
+
+ #define UIP_URGDATA 0
+
+/**
+ * The initial retransmission timeout counted in timer pulses.
+ *
+ * This should not be changed.
+ */
+
+ #define UIP_RTO 3
+
+/**
+ * The maximum number of times a segment should be retransmitted
+ * before the connection should be aborted.
+ *
+ * This should not be changed.
+ */
+
+ #define UIP_MAXRTX 8
+
+/**
+ * The maximum number of times a SYN segment should be retransmitted
+ * before a connection request should be deemed to have been
+ * unsuccessful.
+ *
+ * This should not need to be changed.
+ */
+
+ #define UIP_MAXSYNRTX 5
+
+/**
+ * The TCP maximum segment size.
+ *
+ * This is should not be to set to more than
+ * UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN.
+ */
+
+ #ifndef UIP_CONF_TCP_MSS
+ #define UIP_TCP_MSS (UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN)
+ #else
+ #define UIP_TCP_MSS UIP_CONF_TCP_MSS
+ #endif
+/**
+ * The size of the advertised receiver's window.
+ *
+ * Should be set low (i.e., to the size of the uip_buf buffer) is the
+ * application is slow to process incoming data, or high (32768 bytes)
+ * if the application processes data quickly.
+ *
+ * \hideinitializer
+ */
+
+ #ifndef UIP_CONF_RECEIVE_WINDOW
+ #define UIP_RECEIVE_WINDOW UIP_TCP_MSS
+ #else
+ #define UIP_RECEIVE_WINDOW UIP_CONF_RECEIVE_WINDOW
+ #endif
+/**
+ * How long a connection should stay in the TIME_WAIT state.
+ *
+ * This configiration option has no real implication, and it should be
+ * left untouched.
+ */
+
+ #define UIP_TIME_WAIT_TIMEOUT 120
+
+/** @} */
+
+/*------------------------------------------------------------------------------*/
+/**
+ * \name ARP configuration options
+ * @{
+ */
+/**
+ * The size of the ARP table.
+ *
+ * This option should be set to a larger value if this uIP node will
+ * have many connections from the local network.
+ *
+ * \hideinitializer
+ */
+ #ifdef UIP_CONF_ARPTAB_SIZE
+ #define UIP_ARPTAB_SIZE UIP_CONF_ARPTAB_SIZE
+ #else
+ #define UIP_ARPTAB_SIZE 8
+ #endif
+/**
+ * The maxium age of ARP table entries measured in 10ths of seconds.
+ *
+ * An UIP_ARP_MAXAGE of 120 corresponds to 20 minutes (BSD
+ * default).
+ */
+
+ #define UIP_ARP_MAXAGE 120
+
+/** @} */
+
+/*------------------------------------------------------------------------------*/
+/**
+ * \name General configuration options
+ * @{
+ */
+/**
+ * The size of the uIP packet buffer.
+ *
+ * The uIP packet buffer should not be smaller than 60 bytes, and does
+ * not need to be larger than 1500 bytes. Lower size results in lower
+ * TCP throughput, larger size results in higher TCP throughput.
+ *
+ * \hideinitializer
+ */
+ #ifndef UIP_CONF_BUFFER_SIZE
+ #define UIP_BUFSIZE 400
+ #else /* UIP_CONF_BUFFER_SIZE */
+
+ #define UIP_BUFSIZE UIP_CONF_BUFFER_SIZE
+ #endif /* UIP_CONF_BUFFER_SIZE */
+
+/**
+ * Determines if statistics support should be compiled in.
+ *
+ * The statistics is useful for debugging and to show the user.
+ *
+ * \hideinitializer
+ */
+
+ #ifndef UIP_CONF_STATISTICS
+ #define UIP_STATISTICS 0
+ #else /* UIP_CONF_STATISTICS */
+
+ #define UIP_STATISTICS UIP_CONF_STATISTICS
+ #endif /* UIP_CONF_STATISTICS */
+
+/**
+ * Determines if logging of certain events should be compiled in.
+ *
+ * This is useful mostly for debugging. The function uip_log()
+ * must be implemented to suit the architecture of the project, if
+ * logging is turned on.
+ *
+ * \hideinitializer
+ */
+
+ #ifndef UIP_CONF_LOGGING
+ #define UIP_LOGGING 0
+ #else /* UIP_CONF_LOGGING */
+
+ #define UIP_LOGGING UIP_CONF_LOGGING
+ #endif /* UIP_CONF_LOGGING */
+
+/**
+ * Broadcast support.
+ *
+ * This flag configures IP broadcast support. This is useful only
+ * together with UDP.
+ *
+ * \hideinitializer
+ *
+ */
+
+ #if UIP_UDP && UIP_CONF_BROADCAST
+ #define UIP_BROADCAST UIP_CONF_BROADCAST
+ #else /* UIP_CONF_BROADCAST */
+
+ #define UIP_BROADCAST 0
+ #endif /* UIP_CONF_BROADCAST */
+
+/**
+ * Print out a uIP log message.
+ *
+ * This function must be implemented by the module that uses uIP, and
+ * is called by uIP whenever a log message is generated.
+ */
+void uip_log(char* msg);
+
+/**
+ * The link level header length.
+ *
+ * This is the offset into the uip_buf where the IP header can be
+ * found. For Ethernet, this should be set to 14. For SLIP, this
+ * should be set to 0.
+ *
+ * \hideinitializer
+ */
+
+ #ifdef UIP_CONF_LLH_LEN
+ #define UIP_LLH_LEN UIP_CONF_LLH_LEN
+ #else /* UIP_CONF_LLH_LEN */
+
+ #define UIP_LLH_LEN 14
+ #endif /* UIP_CONF_LLH_LEN */
+
+/** @} */
+
+/*------------------------------------------------------------------------------*/
+/**
+ * \name CPU architecture configuration
+ * @{
+ *
+ * The CPU architecture configuration is where the endianess of the
+ * CPU on which uIP is to be run is specified. Most CPUs today are
+ * little endian, and the most notable exception are the Motorolas
+ * which are big endian. The BYTE_ORDER macro should be changed to
+ * reflect the CPU architecture on which uIP is to be run.
+ */
+/**
+ * The byte order of the CPU architecture on which uIP is to be run.
+ *
+ * This option can be either BIG_ENDIAN (Motorola byte order) or
+ * LITTLE_ENDIAN (Intel byte order).
+ *
+ * \hideinitializer
+ */
+ #ifdef UIP_CONF_BYTE_ORDER
+ #define UIP_BYTE_ORDER UIP_CONF_BYTE_ORDER
+ #else /* UIP_CONF_BYTE_ORDER */
+
+ #define UIP_BYTE_ORDER UIP_LITTLE_ENDIAN
+ #endif /* UIP_CONF_BYTE_ORDER */
+
+/** @} */
+
+/*------------------------------------------------------------------------------*/
+/**
+ * \name Appication specific configurations
+ * @{
+ *
+ * An uIP application is implemented using a single application
+ * function that is called by uIP whenever a TCP/IP event occurs. The
+ * name of this function must be registered with uIP at compile time
+ * using the UIP_APPCALL definition.
+ *
+ * uIP applications can store the application state within the
+ * uip_conn structure by specifying the type of the application
+ * structure by typedef:ing the type uip_tcp_appstate_t and uip_udp_appstate_t.
+ *
+ * The file containing the definitions must be included in the
+ * uipopt.h file.
+ *
+ * The following example illustrates how this can look.
+ \code
+
+void httpd_appcall(void);
+#define UIP_APPCALL httpd_appcall
+
+struct httpd_state {
+ u8_t state;
+ u16_t count;
+ char *dataptr;
+ char *script;
+};
+typedef struct httpd_state uip_tcp_appstate_t
+ \endcode
+ */
+/**
+ * \var #define UIP_APPCALL
+ *
+ * The name of the application function that uIP should call in
+ * response to TCP/IP events.
+ *
+ */
+/**
+ * \var typedef uip_tcp_appstate_t
+ *
+ * The type of the application state that is to be stored in the
+ * uip_conn structure. This usually is typedef:ed to a struct holding
+ * application state information.
+ */
+/**
+ * \var typedef uip_udp_appstate_t
+ *
+ * The type of the application state that is to be stored in the
+ * uip_conn structure. This usually is typedef:ed to a struct holding
+ * application state information.
+ */
+/** @} */
+/** @} */
+#endif /* __UIPOPT_H__ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uitility/util.h Mon Sep 15 11:12:30 2014 +0000 @@ -0,0 +1,13 @@ +#ifndef UTIL_H +#define UTIL_H + +#define htons(x) ( ((x)<<8) | (((x)>>8)&0xFF) ) +#define ntohs(x) htons(x) + +#define htonl(x) ( ((x)<<24 & 0xFF000000UL) | \ + ((x)<< 8 & 0x00FF0000UL) | \ + ((x)>> 8 & 0x0000FF00UL) | \ + ((x)>>24 & 0x000000FFUL) ) +#define ntohl(x) htonl(x) + +#endif