{

static const int kNoContentLengthHeader =-1;

static const int kHttpPort =80;

static const char* kUserAgent;

#ifdef PROXY_ENABLED // currently disabled as introduces dependency on Dns.h in Ethernet

HttpClient(Client& aClient, const char* aProxy =NULL, uint16_t aProxyPort =0);

#else

HttpClient(Client& aClient);

#endif

/** Start a more complex request.

void beginRequest();

/** End a more complex request.

void endRequest();

/** Connect to the server and start to send a GET request.

int get(const char* aServerName, uint16_t aServerPort, const char* aURLPath,

const char* aUserAgent =NULL)

{ return startRequest(aServerName, aServerPort, aURLPath, HTTP_METHOD_GET, aUserAgent); }

/** Connect to the server and start to send a GET request.

int get(const char* aServerName, const char* aURLPath, const char* aUserAgent =NULL)

{ return startRequest(aServerName, kHttpPort, aURLPath, HTTP_METHOD_GET, aUserAgent); }

/** Connect to the server and start to send a GET request. This version connects

int get(const IPAddress& aServerAddress,

const char* aServerName,

uint16_t aServerPort,

const char* aURLPath,

const char* aUserAgent =NULL)

{ return startRequest(aServerAddress, aServerName, aServerPort, aURLPath, HTTP_METHOD_GET, aUserAgent); }

/** Connect to the server and start to send a GET request. This version connects

int get(const IPAddress& aServerAddress,

const char* aServerName,

const char* aURLPath,

const char* aUserAgent =NULL)

{ return startRequest(aServerAddress, aServerName, kHttpPort, aURLPath, HTTP_METHOD_GET, aUserAgent); }

/** Connect to the server and start to send a POST request.

int post(const char* aServerName,

uint16_t aServerPort,

const char* aURLPath,

const char* aUserAgent =NULL)

{ return startRequest(aServerName, aServerPort, aURLPath, HTTP_METHOD_POST, aUserAgent); }

/** Connect to the server and start to send a POST request.

int post(const char* aServerName,

const char* aURLPath,

const char* aUserAgent =NULL)

{ return startRequest(aServerName, kHttpPort, aURLPath, HTTP_METHOD_POST, aUserAgent); }

/** Connect to the server and start to send a POST request. This version connects

int post(const IPAddress& aServerAddress,

const char* aServerName,

uint16_t aServerPort,

const char* aURLPath,

const char* aUserAgent =NULL)

{ return startRequest(aServerAddress, aServerName, aServerPort, aURLPath, HTTP_METHOD_POST, aUserAgent); }

/** Connect to the server and start to send a POST request. This version connects

int post(const IPAddress& aServerAddress,

const char* aServerName,

const char* aURLPath,

const char* aUserAgent =NULL)

{ return startRequest(aServerAddress, aServerName, kHttpPort, aURLPath, HTTP_METHOD_POST, aUserAgent); }

/** Connect to the server and start to send a PUT request.

int put(const char* aServerName,

uint16_t aServerPort,

const char* aURLPath,

const char* aUserAgent =NULL)

{ return startRequest(aServerName, aServerPort, aURLPath, HTTP_METHOD_PUT, aUserAgent); }

/** Connect to the server and start to send a PUT request.

int put(const char* aServerName,

const char* aURLPath,

const char* aUserAgent =NULL)

{ return startRequest(aServerName, kHttpPort, aURLPath, HTTP_METHOD_PUT, aUserAgent); }

/** Connect to the server and start to send a PUT request. This version connects

int put(const IPAddress& aServerAddress,

const char* aServerName,

uint16_t aServerPort,

const char* aURLPath,

const char* aUserAgent =NULL)

{ return startRequest(aServerAddress, aServerName, aServerPort, aURLPath, HTTP_METHOD_PUT, aUserAgent); }

/** Connect to the server and start to send a PUT request. This version connects

int put(const IPAddress& aServerAddress,

const char* aServerName,

const char* aURLPath,

const char* aUserAgent =NULL)

{ return startRequest(aServerAddress, aServerName, kHttpPort, aURLPath, HTTP_METHOD_PUT, aUserAgent); }

/** Connect to the server and start to send the request.

int startRequest(const char* aServerName,

uint16_t aServerPort,

const char* aURLPath,

const char* aHttpMethod,

const char* aUserAgent);

/** Connect to the server and start to send the request.

int startRequest(const IPAddress& aServerAddress,

const char* aServerName,

uint16_t aServerPort,

const char* aURLPath,

const char* aHttpMethod,

const char* aUserAgent);

/** Send an additional header line. This can only be called in between the

void sendHeader(const char* aHeader);

/** Send an additional header line. This is an alternate form of

void sendHeader(const char* aHeaderName, const char* aHeaderValue);

/** Send an additional header line. This is an alternate form of

void sendHeader(const char* aHeaderName, const int aHeaderValue);

/** Send a basic authentication header. This will encode the given username

void sendBasicAuth(const char* aUser, const char* aPassword);

/** Finish sending the HTTP request. This basically just sends the blank

void finishRequest();

/** Get the HTTP status code contained in the response.

int responseStatusCode();

/** Read the next character of the response headers.

int readHeader();

/** Skip any response headers to get to the body.

int skipResponseHeaders();

/** Test whether all of the response headers have been consumed.

bool endOfHeadersReached() { return (iState == eReadingBody); };

/** Test whether the end of the body has been reached.

bool endOfBodyReached();

virtual bool endOfStream() { return endOfBodyReached(); };

virtual bool completed() { return endOfBodyReached(); };

/** Return the length of the body.

int contentLength() { return iContentLength; };

// Inherited from Print

// Note: 1st call to these indicates the user is sending the body, so if need

// Note: be we should finish the header first

virtual size_t write(uint8_t aByte) { if (iState < eRequestSent) { finishHeaders(); }; return iClient-> write(aByte); };

virtual size_t write(const uint8_t *aBuffer, size_t aSize) { if (iState < eRequestSent) { finishHeaders(); }; return iClient->write(aBuffer, aSize); };

// Inherited from Stream

virtual int available() { return iClient->available(); };

/** Read the next byte from the server.

virtual int read();

virtual int read(uint8_t *buf, size_t size);

virtual int peek() { return iClient->peek(); };

virtual void flush() { return iClient->flush(); };

// Inherited from Client

virtual int connect(IPAddress ip, uint16_t port) { return iClient->connect(ip, port); };

virtual int connect(const char *host, uint16_t port) { return iClient->connect(host, port); };

virtual void stop();

virtual uint8_t connected() { return iClient->connected(); };

virtual operator bool() { return bool(iClient); };

virtual uint32_t httpResponseTimeout() { return iHttpResponseTimeout; };

virtual void setHttpResponseTimeout(uint32_t timeout) { iHttpResponseTimeout = timeout; };

/** Reset internal state data back to the "just initialised" state

void resetState();

/** Send the first part of the request and the initial headers.

int sendInitialHeaders(const char* aServerName,

IPAddress aServerIP,

uint16_t aPort,

const char* aURLPath,

const char* aHttpMethod,

const char* aUserAgent);

/* Let the server know that we've reached the end of the headers

void finishHeaders();

// Number of milliseconds that we wait each time there isn't any data

// available to be read (during status code and header processing)

static const int kHttpWaitForDataDelay = 1000;

// Number of milliseconds that we'll wait in total without receiveing any

// data before returning HTTP_ERROR_TIMED_OUT (during status code and header

// processing)

static const int kHttpResponseTimeout = 30*1000;

static const char* kContentLengthPrefix;

typedef enum {

eIdle,

eRequestStarted,

eRequestSent,

eReadingStatusCode,

eStatusCodeRead,

eReadingContentLength,

eSkipToEndOfHeader,

eLineStartingCRFound,

eReadingBody

} tHttpState;

// Ethernet client we're using

Client* iClient;

// Current state of the finite-state-machine

tHttpState iState;

// Stores the status code for the response, once known

int iStatusCode;

// Stores the value of the Content-Length header, if present

int iContentLength;

// How many bytes of the response body have been read by the user

int iBodyLengthConsumed;

// How far through a Content-Length header prefix we are

const char* iContentLengthPtr;

// Address of the proxy to use, if we're using one

IPAddress iProxyAddress;

uint16_t iProxyPort;

uint32_t iHttpResponseTimeout;