improvements to http client and using const char buffers where appropriate

Author: Doug Powers

ARPHandler.cpp

@@ -72,6 +72,7 @@ bool ARPHandler::sendARPRequest(uint8_t target_protocol_addr[4]){
   if (!etherBuffer->write8(5,4)) return false; // IPv4 addresses are 4 bytes
   if (!etherBuffer->writeNet16(6,ARP_REQUEST)) return false;  // 1 is request
   if (!etherBuffer->write(8,sender_hardware_addr,6)) return false; //sender mac
+
   if (!etherBuffer->write(14,ipAddress,4)) return false;           //sender ip
 
  //target hw address

Buffer.cpp

@@ -2,7 +2,7 @@
 #include <string.h>
 #include "Buffer.h"
 
-bool Buffer::write(uint16_t offset, char* d){
+bool Buffer::write(uint16_t offset, const char* d){
   return this->write(offset,d,strlen(d));
 }
 

Buffer.h

@@ -8,7 +8,7 @@ class Buffer {
  public:
   virtual uint16_t size() = 0;
 
-  virtual bool write(uint16_t offset, void* data, uint16_t len) = 0;
+  virtual bool write(uint16_t offset, const void* data, uint16_t len) = 0;
   virtual bool read(uint16_t offset, void* data, uint16_t len) = 0;
 
   virtual bool copyTo(Buffer* destination, uint16_t dest_start = 0, 
@@ -26,7 +26,7 @@ class Buffer {
   bool write8(uint16_t offset, uint8_t d);
   bool write16(uint16_t offset, uint16_t d);
   bool write32(uint16_t offset, uint32_t d); 
-  bool write(uint16_t offset, char* d);
+  bool write(uint16_t offset, const char* d);
 
   bool writeNet16(uint16_t offset, uint16_t d);
   bool writeNet32(uint32_t offset, uint32_t d);

DNSHandler.cpp

@@ -59,7 +59,7 @@ DNSHandler::DNSHandler(UDPHandler* udpHandler,uint8_t *dnsip,
 /*                               P R I V A T E                               */
 /* ========================================================================= */
 // returns false if the UDP buffer is not large enough for the request
-bool DNSHandler::sendDNSRequest(char* domainName, uint16_t id, 
+bool DNSHandler::sendDNSRequest(const char* domainName, uint16_t id, 
 				uint8_t* dnsServer){
 
   if (strlen(domainName) > 255){
@@ -101,7 +101,7 @@ bool DNSHandler::sendDNSRequest(char* domainName, uint16_t id,
   //    0         (note that we end with a 0 length for the root domain)
   uint16_t hostLengthOffset = DNS_HEADER_LENGTH;
 
-  char* nextChar = domainName;
+  const char* nextChar = domainName;
   uint8_t hostLength = 0;
   while (*nextChar != '\0'){
     if (*nextChar == '.'){//toggle to the next host
@@ -155,7 +155,7 @@ bool DNSHandler::sendDNSRequest(char* domainName, uint16_t id,
 /* ========================================================================= */
 /*                                P U B L I C                                */
 /* ========================================================================= */
-uint8_t* DNSHandler::resolve(char* domainName, uint8_t* err, bool force){
+uint8_t* DNSHandler::resolve(const char* domainName, uint8_t* err, bool force){
 
   //first, see if this domainName is in our cache
   for(int i=0; i<cacheSize; i++){

DNSHandler.h

@@ -37,13 +37,13 @@ class DNSHandler: TimerHandler,DatagramReceiver {
   uint8_t* dnsIPBackup;
   uint8_t timer;
 
-  bool sendDNSRequest(char* domainName, uint16_t id, uint8_t *dnsServer);
+  bool sendDNSRequest(const char* domainName, uint16_t id, uint8_t *dnsServer);
   void checkAndSetExpiration(uint8_t i);
 
  public:
   DNSHandler(UDPHandler* udpHandler, uint8_t* dnsip, uint8_t cacheCapcity,
 	     uint8_t* dnsipbackup = NULL);
-  uint8_t* resolve(char* domainName, uint8_t* err, bool force = false);
+  uint8_t* resolve(const char* domainName, uint8_t* err, bool force = false);
   void handleTimer(uint8_t index);
   void handleDatagram(uint8_t* sourceIP, uint16_t sourcePort,Buffer *packet);
   void printDNSCache();

ENC28J60Buffer.cpp

@@ -29,7 +29,7 @@ uint16_t ENC28J60Buffer::size(){
 }
 
 #include <stdio.h>
-bool ENC28J60Buffer::write(uint16_t offset, void* data, uint16_t len){
+bool ENC28J60Buffer::write(uint16_t offset, const void* data, uint16_t len){
 
   uint16_t address = this->bufferStart+this->payloadPointer+offset;
 

ENC28J60Buffer.h

@@ -25,7 +25,7 @@ class ENC28J60Buffer: public Buffer {
 		 bool wrap = false);
 
   uint16_t size();
-  bool write(uint16_t offset, void* data, uint16_t len);
+  bool write(uint16_t offset, const void* data, uint16_t len);
   bool read(uint16_t offset, void* data, uint16_t len);
 
   void setPayloadPointer(uint16_t offset);

ENC28J60Driver.cpp

@@ -37,7 +37,7 @@ class ENC28J60Driver: public EthernetDriver {
 
 public:
 
-  ENC28J60Driver(uint8_t* mac,uint8_t csPin = 8);
+  ENC28J60Driver(uint8_t* mac,uint8_t csPin = 10);
 
   Buffer* getSendBuffer();
   Buffer* getReceiveBuffer();

ENC28J60Driver.h

@@ -3,6 +3,12 @@
 #include <hostutil.h>
 #include "EtherControl.h"
 
+#if ARDUINO >= 100
+#include <Arduino.h> // Arduino 1.0
+#else
+#include <Wprogram.h> // Arduino 0022
+#endif
+
 //#define EMULATE_PACKET_LOSS_PCT 25
 
 #define MAC_SIZE 6
@@ -79,7 +85,6 @@ uint8_t EtherControl::registerTimer(TimerHandler *handler,
       return i+1;
     }
   }//end for
-  
   return 0;
 }
 
@@ -209,7 +214,6 @@ bool EtherControl::sendFrame(const uint8_t *destinationMAC, uint16_t protocol,
 }//send frame
 
 bool EtherControl::processFrame(){
-
   Buffer* recvBuffer = driver->getReceiveBuffer();
 
   uint16_t len = driver->receiveFrame();

ENC28J60Registers.h

@@ -2,50 +2,108 @@
 #include <string.h>
 #include "HTTPClient.h"
 
-HTTPClient::HTTPClient(uint8_t* ip, uint16_t port, char* path)
+HTTPClient::HTTPClient(uint8_t* ip, uint16_t port)
   :Socket(ip,port){
-  this->path = path;
+  this->sendInProgress = false;
 }
 
-HTTPClient::HTTPClient(char* server, DNSHandler* dns, 
-		       uint16_t port, char* path)
+HTTPClient::HTTPClient(const char* server, DNSHandler* dns, uint16_t port)
   :Socket(server,port,dns){
-  this->path = path;
+  this->sendInProgress = false;
 }
 
 #include <Arduino.h>
+
+bool HTTPClient::send(const char* method, const char* path, 
+                      const char* contentType,const char* body) {
+
+  if (!this->readyToSend())
+    return false;
+
+  this->sendInProgress = true;
+
+  this->method = method;
+  this->path = path;
+  this->body = body;
+  this->contentType = contentType;
+  
+  this->connect();
+
+  return true;
+}
+
+bool HTTPClient::readyToSend(){
+  if (this->sendInProgress) return false;
+  if (getState() != CLOSED) return false;
+  return true;
+}
+
 void HTTPClient::onEstablished(){
-  Serial.println("writing");
-  startTime = host_millis();
   Buffer* buf = this->getSendDataBuffer();
-  buf->write(0,(void*)"GET ",4);
-  buf->write(4,path,strlen(path));
-  buf->write(4+strlen(path),(void*)"\n\n",2);
-  this->send(4+strlen(path)+2);
+  uint16_t pos = 0;
+  buf->write(pos,method,strlen(method)); pos += strlen(method);
+  buf->write(pos," ",1); pos += 1;
+  buf->write(pos,path,strlen(path)); pos += strlen(path);
+  buf->write(pos,"\n",1); pos += 1;
+
+  if (body != NULL && strlen(body) > 0) {
+    if (contentType != NULL && strlen(contentType) > 0){
+       buf->write(pos, "Content-Type: "); pos += 14;
+       buf->write(pos, contentType); pos += strlen(contentType);
+       buf->write(pos,"\n",1); pos += 1;
+    }
+
+    buf->write(pos, "Content-Length: "); pos += 16;
+    char contentLength[5];
+    itoa(strlen(body), contentLength, 10);
+    buf->write(pos,contentLength,strlen(contentLength));
+    pos += strlen(contentLength);
+    buf->write(pos,"\n",1); pos += 1;
+  }
+  buf->write(pos,"\n",1); pos += 1;
+  if (body != NULL && strlen(body) > 0) {
+    buf->write(pos,body,strlen(body));
+    pos += strlen(body);
+  }
+  Socket::send(pos);
 }
 
 bool HTTPClient::onDataReceived(Buffer* buf){
-  for(int i=0; i<buf->size(); i++){
-    char c;
-    buf->read(i,&c,1);
-    printf("%c",c);
-  }
+  // this client is really just for uploading data
+  // therefore, we don't care about the result
+
+#ifdef DEBUG
+  uint8_t c;
+  uint16_t offset = 0;
+
+  while(buf->read8(offset++,&c))
+    printf("%c",(char)c);
+
+#endif
   return true;
 }
 
 
 void HTTPClient::onRemoteClosed(){
-  printf("Connection closed by remote host.\n");
+  // connection closed by remote host
+  this->sendInProgress = false;
   close();
 }
 
 void HTTPClient::onClosed(){
-  printf("Closed\n");
+  // closed locally
+
+  //we may be in time-wait which would prevent us from
+  //being able to do another send despite that a new
+  //socket connection will always allocate a different port
+  //so let's force ourselves straight to CLOSED                                 
+  if (this->sendInProgress)
+    forceClose();
+
+  this->sendInProgress = false;
 }
 
 void HTTPClient::onReset(bool resetByRemoteHost){
-  if (resetByRemoteHost)
-    printf("Connection reset by remote host.\n");
-  else
-    printf("Connection reset by client.\n");
+  this->sendInProgress = false;
+
 }

EtherControl.cpp

@@ -5,9 +5,12 @@
 
 class HTTPClient: public Socket{
 
-  char* path;
+  const char* path;
+  const char* method;
+  const char* body;
+  const char* contentType;
   uint32_t bytes;
-  uint32_t startTime;
+  bool sendInProgress;
 
  protected:
   void onEstablished();
@@ -17,10 +20,11 @@ class HTTPClient: public Socket{
   void onReset(bool resetByRemoteHost);
 
  public:
-  HTTPClient(uint8_t* ip, uint16_t port = 80, char* path = "/");
-  HTTPClient(char* server, DNSHandler* dns, 
-	     uint16_t port = 80, char* path = "/");
-
+  HTTPClient(uint8_t* ip, uint16_t port = 80);
+  HTTPClient(const char* server, DNSHandler* dns, uint16_t port = 80);
+  bool send(const char* method, const char* path, 
+            const char* contentType, const char* body);
+  bool readyToSend();
 };
 
 #endif

EtherControl.h

@@ -126,7 +126,7 @@ PacketHandler* IPHandler::getProtocolHandler(uint8_t ipProtocol){
 /*                      T I M E R    R E G I S T R A T I O N                 */
 /* ========================================================================= */
 uint8_t IPHandler::registerTimer(TimerHandler *handler, uint16_t millisDelay){
-  etherControl->registerTimer(handler,millisDelay);
+  return etherControl->registerTimer(handler,millisDelay);
 }
 
 void IPHandler::unregisterTimer(uint8_t index){

EthernetDriver.h

@@ -27,7 +27,7 @@ uint16_t MemBuffer::size(){
   return this->bufferLength;
 }
 
-bool MemBuffer::write(uint16_t offset, void* data, uint16_t len){
+bool MemBuffer::write(uint16_t offset, const void* data, uint16_t len){
   if (offset + len > this->size()) return false;
   memcpy(this->buffer+offset,data,len);
   return true;

HTTPClient.cpp

@@ -16,7 +16,7 @@ class MemBuffer: public Buffer {
 
   uint16_t size();
 
-  bool write(uint16_t offset, void* data, uint16_t len);
+  bool write(uint16_t offset, const void* data, uint16_t len);
   bool read(uint16_t offset, void* data, uint16_t len);
 
   uint8_t getBufferType();

HTTPClient.h

@@ -56,7 +56,7 @@ uint16_t OffsetBuffer::getRootBufferOffset(){
 }
 
 #include <Arduino.h>
-bool OffsetBuffer::write(uint16_t start, void* data, uint16_t len){
+bool OffsetBuffer::write(uint16_t start, const void* data, uint16_t len){
 
   //make sure we are within the bounds of the offset buffer
   if (start+len > this->size()) return false;

IPHandler.cpp

@@ -18,7 +18,7 @@ class OffsetBuffer : public Buffer {
   bool reinit(Buffer *buffer,uint16_t offset, uint16_t length = 0);
 
   uint16_t size();
-  bool write(uint16_t offset, void* data, uint16_t len);
+  bool write(uint16_t offset, const void* data, uint16_t len);
   bool read(uint16_t offset, void* data, uint16_t len);
 
   bool copyTo(Buffer* destination, uint16_t dest_start = 0, 

MemBuffer.cpp

@@ -49,6 +49,8 @@ bool SMTPClient::email(char* from, char* to, char* subject, char* body){
   this->body = body;
 
   this->connect();
+
+  return true;
 }
 
 uint8_t SMTPClient::getStatus(){
@@ -111,14 +113,14 @@ bool SMTPClient::checkCode(char* line, uint16_t code){
   return false;
 }
 
-bool SMTPClient::checkMessage(char* line, char* message){
+bool SMTPClient::checkMessage(const char* line, const char* message){
   char* start = strstr(line," ");
   if (start == NULL) return false;
   start++;
 
   char* finish = strstr(start," ");
   if (finish == NULL)
-    finish = line + strlen(line);
+    finish = (char*)line + strlen(line);
 
   if ((finish - start) != strlen(message)) return false;
 

MemBuffer.h

@@ -23,7 +23,7 @@ class SMTPClient: public Socket{
   char recvLine[40];
 
   void onLineReceived(char* line);
-  bool checkMessage(char*,char*);
+  bool checkMessage(const char*,const char*);
   bool checkCode(char*,uint16_t);
 
  protected: