Merge branch 'master' into wifly_integration

amcewen · amcewen · commit 8e73601b4827 · 2011-08-28T20:28:53.000+01:00
diff --git a/Client.cpp b/Client.cpp
@@ -5,7 +5,7 @@ extern "C" {
   #include "string.h"
 }
 
-#include "WProgram.h"
+#include "Arduino.h"
 
 #include "Ethernet.h"
 #include "Client.h"
@@ -70,19 +70,24 @@ int Client::connect(IPAddress ip, uint16_t port) {
   return 1;
 }
 
-void Client::write(uint8_t b) {
-  if (_sock != MAX_SOCK_NUM)
-    send(_sock, &b, 1);
+size_t Client::write(uint8_t b) {
+  return write(&b, 1);
 }
 
-void Client::write(const char *str) {
-  if (_sock != MAX_SOCK_NUM)
-    send(_sock, (const uint8_t *)str, strlen(str));
+size_t Client::write(const char *str) {
+  return write((const uint8_t *) str, strlen(str));
 }
 
-void Client::write(const uint8_t *buf, size_t size) {
-  if (_sock != MAX_SOCK_NUM)
-    send(_sock, buf, size);
+size_t Client::write(const uint8_t *buf, size_t size) {
+  if (_sock == MAX_SOCK_NUM) {
+    setWriteError();
+    return 0;
+  }
+  if (!send(_sock, buf, size)) {
+    setWriteError();
+    return 0;
+  }
+  return size;
 }
 
 int Client::available() {
@@ -156,18 +161,8 @@ uint8_t Client::status() {
   return W5100.readSnSR(_sock);
 }
 
-// the next three functions are a hack so we can compare the client returned
-// by Server::available() to null, or use it as the condition in an
-// if-statement.  this lets us stay compatible with the Processing network
-// library.
-
-uint8_t Client::operator==(int p) {
-  return _sock == MAX_SOCK_NUM;
-}
-
-uint8_t Client::operator!=(int p) {
-  return _sock != MAX_SOCK_NUM;
-}
+// the next function allows us to use the client returned by
+// Server::available() as the condition in an if-statement.
 
 Client::operator bool() {
   return _sock != MAX_SOCK_NUM;
diff --git a/Client.h b/Client.h
@@ -1,6 +1,6 @@
 #ifndef client_h
 #define client_h
-#include "WProgram.h"	
+#include "Arduino.h"	
 #include "Print.h"
 #include "NetClient.h"
 #include "IPAddress.h"
@@ -14,9 +14,9 @@ class Client : public NetClient {
   uint8_t status();
   virtual int connect(IPAddress ip, uint16_t port);
   virtual int connect(const char *host, uint16_t port);
-  virtual void write(uint8_t);
-  virtual void write(const char *str);
-  virtual void write(const uint8_t *buf, size_t size);
+  virtual size_t write(uint8_t);
+  virtual size_t write(const char *str);
+  virtual size_t write(const uint8_t *buf, size_t size);
   virtual int available();
   virtual int read();
   virtual int read(uint8_t *buf, size_t size);
diff --git a/Dhcp.cpp b/Dhcp.cpp
@@ -6,7 +6,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include "Dhcp.h"
-#include "wiring.h"
+#include "Arduino.h"
 #include "util.h"
 
 int DhcpClass::beginWithDHCP(uint8_t *mac, unsigned long timeout, unsigned long responseTimeout)
@@ -271,11 +271,19 @@ uint8_t DhcpClass::parseDHCPResponse(unsigned long responseTimeout, uint32_t& tr
                 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 :
diff --git a/Dns.cpp b/Dns.cpp
@@ -9,7 +9,7 @@
 #include "Dns.h"
 #include <string.h>
 //#include <stdlib.h>
-#include "wiring.h"
+#include "Arduino.h"
 
 
 #define SOCKET_NONE	255
diff --git a/Ethernet.cpp b/Ethernet.cpp
@@ -33,27 +33,37 @@ int EthernetClass::begin(uint8_t *mac_address)
 }
 
 void EthernetClass::begin(uint8_t *mac_address, IPAddress local_ip)
+{
+  // Assume the DNS server will be the machine on the same network as the local IP
+  // but with last octet being '1'
+  IPAddress dns_server = local_ip;
+  dns_server[3] = 1;
+  begin(mac_address, local_ip, dns_server);
+}
+
+void EthernetClass::begin(uint8_t *mac_address, IPAddress local_ip, IPAddress dns_server)
 {
   // Assume the gateway will be the machine on the same network as the local IP
   // but with last octet being '1'
   IPAddress gateway = local_ip;
   gateway[3] = 1;
-  begin(mac_address, local_ip, gateway);
+  begin(mac_address, local_ip, dns_server, gateway);
 }
 
-void EthernetClass::begin(uint8_t *mac_address, IPAddress local_ip, IPAddress gateway)
+void EthernetClass::begin(uint8_t *mac_address, IPAddress local_ip, IPAddress dns_server, IPAddress gateway)
 {
   IPAddress subnet(255, 255, 255, 0);
-  begin(mac_address, local_ip, gateway, subnet);
+  begin(mac_address, local_ip, dns_server, gateway, subnet);
 }
 
-void EthernetClass::begin(uint8_t *mac, IPAddress local_ip, IPAddress gateway, IPAddress subnet)
+void EthernetClass::begin(uint8_t *mac, IPAddress local_ip, IPAddress dns_server, IPAddress gateway, IPAddress subnet)
 {
   W5100.init();
   W5100.setMACAddress(mac);
   W5100.setIPAddress(local_ip._address);
   W5100.setGatewayIp(gateway._address);
   W5100.setSubnetMask(subnet._address);
+  _dnsServerAddress = dns_server;
 }
 
 IPAddress EthernetClass::localIP()
diff --git a/Ethernet.h b/Ethernet.h
@@ -20,8 +20,9 @@ class EthernetClass {
   // Returns 0 if the DHCP configuration failed, and 1 if it succeeded
   int begin(uint8_t *mac_address);
   void begin(uint8_t *mac_address, IPAddress local_ip);
-  void begin(uint8_t *mac_address, IPAddress local_ip, IPAddress gateway);
-  void begin(uint8_t *mac_address, IPAddress local_ip, IPAddress gateway, IPAddress subnet);
+  void begin(uint8_t *mac_address, IPAddress local_ip, IPAddress dns_server);
+  void begin(uint8_t *mac_address, IPAddress local_ip, IPAddress dns_server, IPAddress gateway);
+  void begin(uint8_t *mac_address, IPAddress local_ip, IPAddress dns_server, IPAddress gateway, IPAddress subnet);
 
   IPAddress localIP();
   IPAddress subnetMask();
diff --git a/Server.cpp b/Server.cpp
@@ -67,26 +67,30 @@ Client Server::available()
   return Client(MAX_SOCK_NUM);
 }
 
-void Server::write(uint8_t b) 
+size_t Server::write(uint8_t b) 
 {
   write(&b, 1);
 }
 
-void Server::write(const char *str) 
+size_t Server::write(const char *str) 
 {
   write((const uint8_t *)str, strlen(str));
 }
 
-void Server::write(const uint8_t *buffer, size_t size) 
+size_t Server::write(const uint8_t *buffer, size_t size) 
 {
+  size_t n = 0;
+  
   accept();
 
   for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
     Client client(sock);
 
     if (EthernetClass::_server_port[sock] == _port &&
       client.status() == SnSR::ESTABLISHED) {
-      client.write(buffer, size);
+      n += client.write(buffer, size);
     }
   }
+  
+  return n;
 }
diff --git a/Server.h b/Server.h
@@ -14,9 +14,9 @@ public NetServer {
   Server(uint16_t);
   Client available();
   virtual void begin();
-  virtual void write(uint8_t);
-  virtual void write(const char *str);
-  virtual void write(const uint8_t *buf, size_t size);
+  virtual size_t write(uint8_t);
+  virtual size_t write(const char *str);
+  virtual size_t write(const uint8_t *buf, size_t size);
 };
 
 #endif
diff --git a/Udp.cpp b/Udp.cpp
@@ -102,21 +102,22 @@ int UDP::endPacket()
   return sendUDP(_sock);
 }
 
-void UDP::write(uint8_t byte)
+size_t UDP::write(uint8_t byte)
 {
-  write(&byte, 1);
+  return write(&byte, 1);
 }
 
-void UDP::write(const char *str)
+size_t UDP::write(const char *str)
 {
   size_t len = strlen(str);
-  write((const uint8_t *)str, len);
+  return write((const uint8_t *)str, len);
 }
 
-void UDP::write(const uint8_t *buffer, size_t size)
+size_t UDP::write(const uint8_t *buffer, size_t size)
 {
   uint16_t bytes_written = bufferData(_sock, _offset, buffer, size);
   _offset += bytes_written;
+  return bytes_written;
 }
 
 int UDP::parsePacket()
diff --git a/Udp.h b/Udp.h
@@ -67,11 +67,11 @@ class UDP : public Stream {
   // Returns 1 if the packet was sent successfully, 0 if there was an error
   int endPacket();
   // Write a single byte into the packet
-  virtual void write(uint8_t);
+  virtual size_t write(uint8_t);
   // Write a string of characters into the packet
-  virtual void write(const char *str);
+  virtual size_t write(const char *str);
   // Write size bytes from buffer into the packet
-  virtual void write(const uint8_t *buffer, size_t size);
+  virtual size_t write(const uint8_t *buffer, size_t size);
 
   // Start processing the next available incoming packet
   // Returns the size of the packet in bytes, or 0 if no packets are available
diff --git a/examples/DhcpAddressPrinter/DhcpAddressPrinter.ino b/examples/DhcpAddressPrinter/DhcpAddressPrinter.ino
@@ -0,0 +1,54 @@
+/*
+  DHCP-based IP printer
+ 
+ This sketch uses the DHCP extensions to the Ethernet library
+ to get an IP address via DHCP and print the address obtained.
+ using an Arduino Wiznet Ethernet shield. 
+ 
+ Circuit:
+ * Ethernet shield attached to pins 10, 11, 12, 13
+ 
+ created 12 April 2011
+ by Tom Igoe
+ 
+ */
+
+#include <SPI.h>
+#include <Ethernet.h>
+
+// Enter a MAC address for your controller below.
+// Newer Ethernet shields have a MAC address printed on a sticker on the shield
+byte mac[] = {  
+  0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02 };
+
+// Initialize the Ethernet client library
+// with the IP address and port of the server 
+// that you want to connect to (port 80 is default for HTTP):
+Client client;
+
+void setup() {
+  // start the serial library:
+  Serial.begin(9600);
+  // start the Ethernet connection:
+  Serial.println("Trying to get an IP address using DHCP");z
+  if (Ethernet.begin(mac) == 0) {
+    Serial.println("Failed to configure Ethernet using DHCP");
+    // no point in carrying on, so do nothing forevermore:
+    while(true);
+  }
+  // print your local IP address:
+  Serial.print("My IP address: ");
+  IPAddress myIPAddress = Ethernet.localIP();
+  for (byte thisByte = 0; thisByte < 4; thisByte++) {
+    // print the value of each byte of the IP address:
+    Serial.print(myIPAddress[thisByte], DEC);
+    Serial.print("."); 
+  }
+  Serial.println();
+}
+
+void loop() {
+
+}
+
+
diff --git a/examples/DhcpAddressPrinter/DhcpAddressPrinter.pde b/examples/DhcpAddressPrinter/DhcpAddressPrinter.pde
@@ -0,0 +1,53 @@
+/*
+  DHCP-based IP printer
+ 
+ This sketch uses the DHCP extensions to the Ethernet library
+ to get an IP address via DHCP and print the address obtained.
+ using an Arduino Wiznet Ethernet shield. 
+ 
+ Circuit:
+ * Ethernet shield attached to pins 10, 11, 12, 13
+ 
+ created 12 April 2011
+ by Tom Igoe
+ 
+ */
+
+#include <SPI.h>
+#include <Ethernet.h>
+
+// Enter a MAC address for your controller below.
+// Newer Ethernet shields have a MAC address printed on a sticker on the shield
+byte mac[] = {  
+  0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02 };
+
+// Initialize the Ethernet client library
+// with the IP address and port of the server 
+// that you want to connect to (port 80 is default for HTTP):
+Client client;
+
+void setup() {
+  // start the serial library:
+  Serial.begin(9600);
+  // start the Ethernet connection:
+  if (Ethernet.begin(mac) == 0) {
+    Serial.println("Failed to configure Ethernet using DHCP");
+    // no point in carrying on, so do nothing forevermore:
+    for(;;)
+      ;
+  }
+  // print your local IP address:
+  Serial.print("My IP address: ");
+  for (byte thisByte = 0; thisByte < 4; thisByte++) {
+    // print the value of each byte of the IP address:
+    Serial.print(Ethernet.localIP()[thisByte], DEC);
+    Serial.print("."); 
+  }
+  Serial.println();
+}
+
+void loop() {
+
+}
+
+
diff --git a/examples/DhcpChatServer/DhcpChatServer.ino b/examples/DhcpChatServer/DhcpChatServer.ino
diff --git a/examples/DnsWebClient/DnsWebClient.pde b/examples/DnsWebClient/DnsWebClient.pde
diff --git a/examples/TwitterClient/TwitterClient.ino b/examples/TwitterClient/TwitterClient.ino
diff --git a/utility/w5100.h b/utility/w5100.h

Original file line number	Diff line number	Diff line change
`@@ -33,27 +33,37 @@ int EthernetClass::begin(uint8_t *mac_address)`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`void EthernetClass::begin(uint8_t *mac_address, IPAddress local_ip)`
	`36`	`+{`
	`37`	`+ // Assume the DNS server will be the machine on the same network as the local IP`
	`38`	`+ // but with last octet being '1'`
	`39`	`+ IPAddress dns_server = local_ip;`
	`40`	`+ dns_server[3] = 1;`
	`41`	`+ begin(mac_address, local_ip, dns_server);`
	`42`	`+}`
	`43`	`+`
	`44`	`+void EthernetClass::begin(uint8_t *mac_address, IPAddress local_ip, IPAddress dns_server)`
`36`	`45`	`{`
`37`	`46`	`// Assume the gateway will be the machine on the same network as the local IP`
`38`	`47`	`// but with last octet being '1'`
`39`	`48`	`IPAddress gateway = local_ip;`
`40`	`49`	`gateway[3] = 1;`
`41`		`- begin(mac_address, local_ip, gateway);`
	`50`	`+ begin(mac_address, local_ip, dns_server, gateway);`
`42`	`51`	`}`
`43`	`52`
`44`		`-void EthernetClass::begin(uint8_t *mac_address, IPAddress local_ip, IPAddress gateway)`
	`53`	`+void EthernetClass::begin(uint8_t *mac_address, IPAddress local_ip, IPAddress dns_server, IPAddress gateway)`
`45`	`54`	`{`
`46`	`55`	`IPAddress subnet(255, 255, 255, 0);`
`47`		`- begin(mac_address, local_ip, gateway, subnet);`
	`56`	`+ begin(mac_address, local_ip, dns_server, gateway, subnet);`
`48`	`57`	`}`
`49`	`58`
`50`		`-void EthernetClass::begin(uint8_t *mac, IPAddress local_ip, IPAddress gateway, IPAddress subnet)`
	`59`	`+void EthernetClass::begin(uint8_t *mac, IPAddress local_ip, IPAddress dns_server, IPAddress gateway, IPAddress subnet)`
`51`	`60`	`{`
`52`	`61`	`W5100.init();`
`53`	`62`	`W5100.setMACAddress(mac);`
`54`	`63`	`W5100.setIPAddress(local_ip._address);`
`55`	`64`	`W5100.setGatewayIp(gateway._address);`
`56`	`65`	`W5100.setSubnetMask(subnet._address);`
	`66`	`+ _dnsServerAddress = dns_server;`
`57`	`67`	`}`
`58`	`68`
`59`	`69`	`IPAddress EthernetClass::localIP()`
Original file line number	Diff line number	Diff line change
`@@ -67,26 +67,30 @@ Client Server::available()`
`67`	`67`	`return Client(MAX_SOCK_NUM);`
`68`	`68`	`}`
`69`	`69`
`70`		`-void Server::write(uint8_t b)`
	`70`	`+size_t Server::write(uint8_t b)`
`71`	`71`	`{`
`72`	`72`	`write(&b, 1);`
`73`	`73`	`}`
`74`	`74`
`75`		`-void Server::write(const char *str)`
	`75`	`+size_t Server::write(const char *str)`
`76`	`76`	`{`
`77`	`77`	`write((const uint8_t *)str, strlen(str));`
`78`	`78`	`}`
`79`	`79`
`80`		`-void Server::write(const uint8_t *buffer, size_t size)`
	`80`	`+size_t Server::write(const uint8_t *buffer, size_t size)`
`81`	`81`	`{`
	`82`	`+ size_t n = 0;`
	`83`	`+`
`82`	`84`	`accept();`
`83`	`85`
`84`	`86`	`for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {`
`85`	`87`	`Client client(sock);`
`86`	`88`
`87`	`89`	`if (EthernetClass::_server_port[sock] == _port &&`
`88`	`90`	`client.status() == SnSR::ESTABLISHED) {`
`89`		`- client.write(buffer, size);`
	`91`	`+ n += client.write(buffer, size);`
`90`	`92`	`}`
`91`	`93`	`}`
	`94`	`+`
	`95`	`+ return n;`
`92`	`96`	`}`
Original file line number	Diff line number	Diff line change
`@@ -102,21 +102,22 @@ int UDP::endPacket()`
`102`	`102`	`return sendUDP(_sock);`
`103`	`103`	`}`
`104`	`104`
`105`		`-void UDP::write(uint8_t byte)`
	`105`	`+size_t UDP::write(uint8_t byte)`
`106`	`106`	`{`
`107`		`- write(&byte, 1);`
	`107`	`+ return write(&byte, 1);`
`108`	`108`	`}`
`109`	`109`
`110`		`-void UDP::write(const char *str)`
	`110`	`+size_t UDP::write(const char *str)`
`111`	`111`	`{`
`112`	`112`	`size_t len = strlen(str);`
`113`		`- write((const uint8_t *)str, len);`
	`113`	`+ return write((const uint8_t *)str, len);`
`114`	`114`	`}`
`115`	`115`
`116`		`-void UDP::write(const uint8_t *buffer, size_t size)`
	`116`	`+size_t UDP::write(const uint8_t *buffer, size_t size)`
`117`	`117`	`{`
`118`	`118`	`uint16_t bytes_written = bufferData(_sock, _offset, buffer, size);`
`119`	`119`	`_offset += bytes_written;`
	`120`	`+ return bytes_written;`
`120`	`121`	`}`
`121`	`122`
`122`	`123`	`int UDP::parsePacket()`