这是arduinohtpclient库中的HttpClient.cpp的内容// Class to simplify HTTP fetching on Arduino
// (c) Copyright 2010-2011 MCQN Ltd
// Released under Apache License, version 2.0
#include "HttpClient.h"
#include "b64.h"
// Initialize constants
const char* HttpClient::kUserAgent = "Arduino/2.2.0";
const char* HttpClient::kContentLengthPrefix = HTTP_HEADER_CONTENT_LENGTH ": ";
const char* HttpClient::kTransferEncodingChunked = HTTP_HEADER_TRANSFER_ENCODING ": " HTTP_HEADER_VALUE_CHUNKED;
HttpClient::HttpClient(Client& aClient, const char* aServerName, uint16_t aServerPort)
: iClient(&aClient),
iServerName(aServerName),
iServerAddress(),
iServerPort(aServerPort),
iConnectionClose(true),
iSendDefaultReques
tHeaders(true)
{
resetState();
}
HttpClient::HttpClient(Client& aClient, const String& aServerName, uint16_t aServerPort)
: HttpClient(aClient, aServerName.c_str(), aServerPort)
{
}
HttpClient::HttpClient(Client& aClient, const IPAddress& aServerAddress, uint16_t aServerPort)
: iClient(&aClient),
iServerName(NULL),
iServerAddress(aServerAddress),
iServerPort(aServerPort),
iConnectionClose(true),
iSendDefaultReques
tHeaders(true)
{
resetState();
}
void HttpClient::resetState()
{
iState = eIdle;
iStatusCode = 0;
iContentLength = kNoContentLengthHeader;
iBodyLengthConsumed = 0;
iContentLengthPtr = kContentLengthPrefix;
iTransferEncodingChunkedPtr = kTransferEncodingChunked;
i
IsChunked = false;
iChunkLength = 0;
iHttpResponseTimeout = kHttpResponseTimeout;
iHttpWaitForDataDelay = kHttpWaitForDataDelay;
}
void HttpClient::stop()
{
iClient->stop();
resetState();
}
void HttpClient::connectionKeepAlive()
{
iConnectionClose = false;
}
void HttpClient::noDefaultReques
tHeaders()
{
iSendDefaultReques
tHeaders = false;
}
void HttpClient::beginRequest()
{
iState = eRequestStarted;
}
int HttpClient::startRequest(const char* aURLPath, const char* aHttpMethod,
const char* aContentType, int aContentLength, const byte aBody[])
{
if (
iState == eReadingBody ||
iState == eReadingChunkLength ||
iState == eReadingBodyChunk)
{
flushClientRx();
resetState();
}
tHttpState initialState =
iState;
if ((eIdle !=
iState) && (eRequestStarted !=
iState))
{
return HTTP_ERROR_API;
}
if (iConnectionClose || !iClient->connected())
{
if (
iServerName)
{
if (!(iClient->connect(
iServerName,
iServerPort) > 0))
{
#ifdef LOGGING
Serial.println("Connection failed");
#endif
return HTTP_ERROR_CONNECTION_FAILED;
}
}
else
{
if (!(iClient->connect(
iServerAddress,
iServerPort) > 0))
{
#ifdef LOGGING
Serial.println("Connection failed");
#endif
return HTTP_ERROR_CONNECTION_FAILED;
}
}
}
else
{
#ifdef LOGGING
Serial.println("Connection already open");
#endif
}
// Now we're connected, send
the first part of
the request
int ret = sendInitialHeaders(aURLPath, aHttpMethod);
if (HTTP_SUCCESS == ret)
{
if (aContentType)
{
sendHeader(HTTP_HEADER_CONTENT_TYPE, aContentType);
}
if (aContentLength > 0)
{
sendHeader(HTTP_HEADER_CONTENT_LENGTH, aContentLength);
}
bool hasBody = (aBody && aContentLength > 0);
if (initialState == eIdle || hasBody)
{
// Th
is was a simple version of
the API, so terminate
the headers now
fin
ishHeaders();
}
// else we'll call it in endRequest or in
the first call to print, etc.
if (hasBody)
{
write(aBody, aContentLength);
}
}
return ret;
}
int HttpClient::sendInitialHeaders(const char* aURLPath, const char* aHttpMethod)
{
#ifdef LOGGING
Serial.println("Connected");
#endif
// Send
the HTTP command, i.e. "GET /somepath/ HTTP/1.0"
iClient->print(aHttpMethod);
iClient->print(" ");
iClient->print(aURLPath);
iClient->println(" HTTP/1.1");
if (
iSendDefaultReques
tHeaders)
{
//
The host header, if required
if (
iServerName)
{
iClient->print("Host: ");
iClient->print(
iServerName);
if (
iServerPort != kHttpPort &&
iServerPort != kHttpsPort)
{
iClient->print(":");
iClient->print(
iServerPort);
}
iClient->println();
}
// And user-agent string
sendHeader(HTTP_HEADER_USER_AGENT, kUserAgent);
}
if (iConnectionClose)
{
// Tell
the server to
// close th
is connection after we're done
sendHeader(HTTP_HEADER_CONNECTION, "close");
}
// Everything has
gone well
iState = eRequestStarted;
return HTTP_SUCCESS;
}
void HttpClient::sendHeader(const char* aHeader)
{
iClient->println(aHeader);
}
void HttpClient::sendHeader(const char* aHeaderName, const char* aHeaderValue)
{
iClient->print(aHeaderName);
iClient->print(": ");
iClient->println(aHeaderValue);
}
void HttpClient::sendHeader(const char* aHeaderName, const int aHeaderValue)
{
iClient->print(aHeaderName);
iClient->print(": ");
iClient->println(aHeaderValue);
}
void HttpClient::sendBasicAuth(const char* aUser, const char* aPassword)
{
// Send
the initial part of th
is header line
iClient->print("Authorization: Basic ");
// Now Base64 encode "aUser:aPassword" and send that
// Th
is seems trickier than it should be but it's mostly to avoid ei
ther
// (a) some arbitrarily sized buffer which hopes to be big enough, or
// (b) allocating and freeing
memory
// ...so we'll loop through 3 bytes at a time, outputting
the results as we
// go.
// In Base64, each 3 bytes of unencoded data become 4 bytes of encoded data
unsigned char input[3];
unsigned char output[5]; // Leave space for a '\0' terminator so we can easily print
int userLen = strlen(aUser);
int passwordLen = strlen(aPassword);
int inputOffset = 0;
for (int i = 0; i < (userLen+1+passwordLen); i++)
{
// Copy
the relevant input byte into
the input
if (i < userLen)
{
input[inputOffset++] = aUser[i];
}
else if (i == userLen)
{
input[inputOffset++] = ':';
}
else
{
input[inputOffset++] = aPassword[i-(userLen+1)];
}
// See if we've got a chunk to encode
if ( (inputOffset == 3) || (i == userLen+passwordLen) )
{
// We've ei
ther got to a 3-byte boundary, or we've reached
then end
b64_encode(input, inputOffset, output, 4);
// NUL-terminate
the output string
output[4] = '\0';
// And write it out
iClient->print((char*)output);
// FIXME We might want to fill output with '=' characters if b64_encode doesn't
// FIXME do it for us when we're encoding
the final chunk
inputOffset = 0;
}
}
// And end
the header we've sent
iClient->println();
}
void HttpClient::fin
ishHeaders()
{
iClient->println();
iState = eRequestSent;
}
void HttpClient::flushClientRx()
{
while (iClient->available())
{
iClient->read();
}
}
void HttpClient::endRequest()
{
beginBody();
}
void HttpClient::beginBody()
{
if (
iState < eRequestSent)
{
// We still need to fin
ish off
the headers
fin
ishHeaders();
}
// else
the end of headers has already been sent, so nothing to do here
}
int HttpClient::get(const char* aURLPath)
{
return startRequest(aURLPath, HTTP_METHOD_GET);
}
int HttpClient::get(const String& aURLPath)
{
return get(aURLPath.c_str());
}
int HttpClient::post(const char* aURLPath)
{
return startRequest(aURLPath, HTTP_METHOD_POST);
}
int HttpClient::post(const String& aURLPath)
{
return post(aURLPath.c_str());
}
int HttpClient::post(const char* aURLPath, const char* aContentType, const char* aBody)
{
return post(aURLPath, aContentType, strlen(aBody), (const byte*)aBody);
}
int HttpClient::post(const String& aURLPath, const String& aContentType, const String& aBody)
{
return post(aURLPath.c_str(), aContentType.c_str(), aBody.length(), (const byte*)aBody.c_str());
}
int HttpClient::post(const char* aURLPath, const char* aContentType, int aContentLength, const byte aBody[])
{
return startRequest(aURLPath, HTTP_METHOD_POST, aContentType, aContentLength, aBody);
}
int HttpClient::put(const char* aURLPath)
{
return startRequest(aURLPath, HTTP_METHOD_PUT);
}
int HttpClient::put(const String& aURLPath)
{
return put(aURLPath.c_str());
}
int HttpClient::put(const char* aURLPath, const char* aContentType, const char* aBody)
{
return put(aURLPath, aContentType, strlen(aBody), (const byte*)aBody);
}
int HttpClient::put(const String& aURLPath, const String& aContentType, const String& aBody)
{
return put(aURLPath.c_str(), aContentType.c_str(), aBody.length(), (const byte*)aBody.c_str());
}
int HttpClient::put(const char* aURLPath, const char* aContentType, int aContentLength, const byte aBody[])
{
return startRequest(aURLPath, HTTP_METHOD_PUT, aContentType, aContentLength, aBody);
}
int HttpClient::patch(const char* aURLPath)
{
return startRequest(aURLPath, HTTP_METHOD_PATCH);
}
int HttpClient::patch(const String& aURLPath)
{
return patch(aURLPath.c_str());
}
int HttpClient::patch(const char* aURLPath, const char* aContentType, const char* aBody)
{
return patch(aURLPath, aContentType, strlen(aBody), (const byte*)aBody);
}
int HttpClient::patch(const String& aURLPath, const String& aContentType, const String& aBody)
{
return patch(aURLPath.c_str(), aContentType.c_str(), aBody.length(), (const byte*)aBody.c_str());
}
int HttpClient::patch(const char* aURLPath, const char* aContentType, int aContentLength, const byte aBody[])
{
return startRequest(aURLPath, HTTP_METHOD_PATCH, aContentType, aContentLength, aBody);
}
int HttpClient::del(const char* aURLPath)
{
return startRequest(aURLPath, HTTP_METHOD_DELETE);
}
int HttpClient::del(const String& aURLPath)
{
return del(aURLPath.c_str());
}
int HttpClient::del(const char* aURLPath, const char* aContentType, const char* aBody)
{
return del(aURLPath, aContentType, strlen(aBody), (const byte*)aBody);
}
int HttpClient::del(const String& aURLPath, const String& aContentType, const String& aBody)
{
return del(aURLPath.c_str(), aContentType.c_str(), aBody.length(), (const byte*)aBody.c_str());
}
int HttpClient::del(const char* aURLPath, const char* aContentType, int aContentLength, const byte aBody[])
{
return startRequest(aURLPath, HTTP_METHOD_DELETE, aContentType, aContentLength, aBody);
}
int HttpClient::responseStatusCode()
{
if (
iState < eRequestSent)
{
return HTTP_ERROR_API;
}
//
The first line will be of
the form Status-Line:
// HTTP-Version SP Status-Code SP Reason-Phrase CRLF
//
Where HTTP-Version
is of
the form:
// HTTP-Version = "HTTP" "/" 1*DIGIT "." 1*DIGIT
int c = '\0';
do
{
// Make sure
the status code
is reset, and likew
ise
the state. Th
is
// lets us easily cope with 1xx informational responses by just
// ignoring
them really, and reading
the next line for a proper response
iStatusCode = 0;
iState = eRequestSent;
unsigned long timeoutStart = mill
is();
// Psuedo-regexp we're expecting before
the status-code
const char* statusPrefix = "HTTP/*.* ";
const char* statusPtr = statusPrefix;
// Whilst we haven't timed out & haven't reached
the end of
the headers
while ((c != '\n') &&
( (mill
is() - timeoutStart) < iHttpResponseTimeout ))
{
if (available())
{
c = HttpClient::read();
if (c != -1)
{
switch(
iState)
{
case eRequestSent:
// We haven't reached
the status code yet
if ( (*statusPtr == '*') || (*statusPtr == c) )
{
// Th
is character matches, just move along
statusPtr++;
if (*statusPtr == '\0')
{
// We've reached
the end of
the prefix
iState = eReadingStatusCode;
}
}
else
{
return HTTP_ERROR_INVALID_RESPONSE;
}
break;
case eReadingStatusCode:
if (
isdigit(c))
{
// Th
is assumes we won't get more than
the 3 digits we
// want
iStatusCode =
iStatusCode*10 + (c - '0');
}
else
{
// We've reached
the end of
the status code
// We could sanity check it here or double-check for ' '
// ra
ther than anything else, but let's be lenient
iState = eStatusCodeRead;
}
break;
case eStatusCodeRead:
// We're just waiting for
the end of
the line now
break;
default:
break;
};
// We read something, reset
the timeout counter
timeoutStart = mill
is();
}
}
else
{
// We haven't got any data, so let's pause to allow some to
// arrive
delay(iHttpWaitForDataDelay);
}
}
if ( (c == '\n') && (
iStatusCode < 200 &&
iStatusCode != 101) )
{
// We've reached
the end of an informational status line
c = '\0'; // Clear c so we'll go back into
the data reading loop
}
}
// If we've read a status code successfully but it's informational (1xx)
// loop back to
the start
while ( (
iState == eStatusCodeRead) && (
iStatusCode < 200 &&
iStatusCode != 101) );
if ( (c == '\n') && (
iState == eStatusCodeRead) )
{
// We've read
the status-line successfully
return
iStatusCode;
}
else if (c != '\n')
{
// We must've timed out before we reached
the end of
the line
return HTTP_ERROR_TIMED_OUT;
}
else
{
// Th
is wasn't a properly formed status line, or at least not one we
// could understand
return HTTP_ERROR_INVALID_RESPONSE;
}
}
int HttpClient::skipResponseHeaders()
{
// Just keep reading until we fin
ish reading
the headers or time out
unsigned long timeoutStart = mill
is();
// Whilst we haven't timed out & haven't reached
the end of
the headers
while ((!endOfHeadersReached()) &&
( (mill
is() - timeoutStart) < iHttpResponseTimeout ))
{
if (available())
{
(void)readHeader();
// We read something, reset
the timeout counter
timeoutStart = mill
is();
}
else
{
// We haven't got any data, so let's pause to allow some to
// arrive
delay(iHttpWaitForDataDelay);
}
}
if (endOfHeadersReached())
{
// Success
return HTTP_SUCCESS;
}
else
{
// We must've timed out
return HTTP_ERROR_TIMED_OUT;
}
}
bool HttpClient::endOfHeadersReached()
{
return (
iState == eReadingBody ||
iState == eReadingChunkLength ||
iState == eReadingBodyChunk);
};
long HttpClient::contentLength()
{
// skip
the response headers, if
they haven't been read already
if (!endOfHeadersReached())
{
skipResponseHeaders();
}
return iContentLength;
}
String HttpClient::responseBody()
{
int bodyLength = contentLength();
String response;
if (bodyLength > 0)
{
// try to reserve bodyLength bytes
if (response.reserve(bodyLength) == 0) {
// String reserve failed
return String((const char*)NULL);
}
}
// keep on timedRead'ing, until:
// - we have a content length: body length equals consumed or no bytes
// available
// - no content length: no bytes are available
while (iBodyLengthConsumed != bodyLength)
{
int c = timedRead();
if (c == -1) {
// read timed out, done
break;
}
if (!response.concat((char)c)) {
// adding char failed
return String((const char*)NULL);
}
}
if (bodyLength > 0 && (unsigned int)bodyLength != response.length()) {
// failure, we did not read in response content length bytes
return String((const char*)NULL);
}
return response;
}
bool HttpClient::endOfBodyReached()
{
if (endOfHeadersReached() && (contentLength() != kNoContentLengthHeader))
{
// We've got to
the body and we know how long it will be
return (iBodyLengthConsumed >= contentLength());
}
return false;
}
int HttpClient::available()
{
if (
iState == eReadingChunkLength)
{
while (iClient->available())
{
char c = iClient->read();
if (c == '\n')
{
iState = eReadingBodyChunk;
break;
}
else if (c == '\r')
{
// no-op
}
else if (
isHexadecimalDigit(c))
{
char digit[2] = {c, '\0'};
iChunkLength = (iChunkLength * 16) + strtol(digit, NULL, 16);
}
}
}
if (
iState == eReadingBodyChunk && iChunkLength == 0)
{
iState = eReadingChunkLength;
}
if (
iState == eReadingChunkLength)
{
return 0;
}
int clientAvailable = iClient->available();
if (
iState == eReadingBodyChunk)
{
return min(clientAvailable, iChunkLength);
}
else
{
return clientAvailable;
}
}
int HttpClient::read()
{
if (i
IsChunked && !available())
{
return -1;
}
int ret = iClient->read();
if (ret >= 0)
{
if (endOfHeadersReached() && iContentLength > 0)
{
// We're outputting
the body now and we've seen a Content-Length header
// So keep track of how many bytes are left
iBodyLengthConsumed++;
}
if (
iState == eReadingBodyChunk)
{
iChunkLength--;
if (iChunkLength == 0)
{
iState = eReadingChunkLength;
}
}
}
return ret;
}
bool HttpClient::headerAvailable()
{
// clear
the currently stored header line
iHeaderLine = "";
while (!endOfHeadersReached())
{
// read a byte from
the header
int c = readHeader();
if (c == '\r' || c == '\n')
{
if (iHeaderLine.length())
{
// end of
the line, all done
break;
}
else
{
// ignore any CR or LF characters
continue;
}
}
// append byte to header line
iHeaderLine += (char)c;
}
return (iHeaderLine.length() > 0);
}
String HttpClient::readHeaderName()
{
int colonIndex = iHeaderLine.indexOf(':');
if (colonIndex == -1)
{
return "";
}
return iHeaderLine.substring(0, colonIndex);
}
String HttpClient::readHeaderValue()
{
int colonIndex = iHeaderLine.indexOf(':');
int startIndex = colonIndex + 1;
if (colonIndex == -1)
{
return "";
}
// trim any leading whitespace
while (startIndex < (int)iHeaderLine.length() &&
isSpace(iHeaderLine[startIndex]))
{
startIndex++;
}
return iHeaderLine.substring(startIndex);
}
int HttpClient::read(uint8_t *buf, size_t size)
{
int ret =iClient->read(buf, size);
if (endOfHeadersReached() && iContentLength > 0)
{
// We're outputting
the body now and we've seen a Content-Length header
// So keep track of how many bytes are left
if (ret >= 0)
{
iBodyLengthConsumed += ret;
}
}
return ret;
}
int HttpClient::readHeader()
{
char c = HttpClient::read();
if (endOfHeadersReached())
{
// We've passed
the headers, but ra
ther than return an error, we'll just
// act as a slightly
less efficient version of read()
return c;
}
// Whilst reading out
the headers to whoever wants
them, we'll keep an
// eye out for
the "Content-Length" header
switch(
iState)
{
case eStatusCodeRead:
// We're at
the start of a line, or some
where in
the middle of reading
//
the Content-Length prefix
if (*iContentLengthPtr == c)
{
// Th
is character matches, just move along
iContentLengthPtr++;
if (*iContentLengthPtr == '\0')
{
// We've reached
the end of
the prefix
iState = eReadingContentLength;
// Just in case we get multiple Content-Length headers, th
is
// will ensure we just get
the value of
the last one
iContentLength = 0;
iBodyLengthConsumed = 0;
}
}
else if (*iTransferEncodingChunkedPtr == c)
{
// Th
is character matches, just move along
iTransferEncodingChunkedPtr++;
if (*iTransferEncodingChunkedPtr == '\0')
{
// We've reached
the end of
the Transfer Encoding: chunked header
i
IsChunked = true;
iState = eSkipToEndOfHeader;
}
}
else if (((iContentLengthPtr == kContentLengthPrefix) && (iTransferEncodingChunkedPtr == kTransferEncodingChunked)) && (c == '\r'))
{
// We've found a '\r' at
the start of a line, so th
is is probably
//
the end of
the headers
iState = eLineStartingCRFound;
}
else
{
// Th
is isn't
the Content-Length or Transfer Encoding chunked header, skip to
the end of
the line
iState = eSkipToEndOfHeader;
}
break;
case eReadingContentLength:
if (
isdigit(c))
{
long _iContentLength = iContentLength*10 + (c - '0');
// Only apply if
the value didn't wrap around
if (_iContentLength > iContentLength) {
iContentLength = _iContentLength;
}
}
else
{
// We've reached
the end of
the content length
// We could sanity check it here or double-check for "\r\n"
// ra
ther than anything else, but let's be lenient
iState = eSkipToEndOfHeader;
}
break;
case eLineStartingCRFound:
if (c == '\n')
{
if (i
IsChunked)
{
iState = eReadingChunkLength;
iChunkLength = 0;
}
else
{
iState = eReadingBody;
}
}
break;
default:
// We're just waiting for
the end of
the line now
break;
};
if ( (c == '\n') && !endOfHeadersReached() )
{
// We've got to
the end of th
is line, start processing again
iState = eStatusCodeRead;
iContentLengthPtr = kContentLengthPrefix;
iTransferEncodingChunkedPtr = kTransferEncodingChunked;
}
// And return
the character read to whoever wants it
return c;
}
这是HttpClient.h头文件的内容// Class to simplify HTTP fetching on Arduino
// (c) Copyright MCQN Ltd. 2010-2012
// Released under Apache License, version 2.0
#ifndef HttpClient_h
#define HttpClient_h
#include <Arduino.h>
#include <IPAddress.h>
#include "Client.h"
static const int HTTP_SUCCESS =0;
//
The end of
the headers has been reached. Th
is consumes
the '\n'
// Could not connect to
the server
static const int HTTP_ERROR_CONNECTION_FAILED =-1;
// Th
is call was made when
the HttpClient class wasn't expecting it
// to be called. Usually indicates your code
is using
the class
// incorrectly
static const int HTTP_ERROR_API =-2;
// Spent too long waiting for a reply
static const int HTTP_ERROR_TIMED_OUT =-3;
//
The response from
the server
is invalid,
is it definitely an HTTP
// server
?
static const int HTTP_ERROR_INVALID_RESPONSE =-4;
// Define some of
the common methods and headers here
// That lets o
ther code reuse
them without having to declare ano
ther copy
// of
them, so saves code space and RAM
#define HTTP_METHOD_GET "GET"
#define HTTP_METHOD_POST "POST"
#define HTTP_METHOD_PUT "PUT"
#define HTTP_METHOD_PATCH "PATCH"
#define HTTP_METHOD_DELETE "DELETE"
#define HTTP_HEADER_CONTENT_LENGTH "Content-Length"
#define HTTP_HEADER_CONTENT_TYPE "Content-Type"
#define HTTP_HEADER_CONNECTION "Connection"
#define HTTP_HEADER_TRANSFER_ENCODING "Transfer-Encoding"
#define HTTP_HEADER_USER_AGENT "User-Agent"
#define HTTP_HEADER_VALUE_CHUNKED "chunked"
class HttpClient : public Client
{
public:
static const int kNoContentLengthHeader =-1;
static const int kHttpPort =80;
static const int kHttpsPort =443;
static const char* kUserAgent;
// FIXME Write longer API request, using port and user-agent, example
// FIXME
Update tempToPachube example to calculate Content-Length correctly
HttpClient(Client& aClient, const char* aServerName, uint16_t aServerPort = kHttpPort);
HttpClient(Client& aClient, const String& aServerName, uint16_t aServerPort = kHttpPort);
HttpClient(Client& aClient, const IPAddress& aServerAddress, uint16_t aServerPort = kHttpPort);
/** Start a more complex request.
Use th
is when you need to send additional headers in
the request,
but you will also need to call endRequest() when you are fin
ished.
*/
void beginRequest();
/** End a more complex request.
Use th
is when you need to have sent additional headers in
the request,
but you will also need to call beginRequest() at
the start.
*/
void endRequest();
/** Start
the body of a more complex request.
Use th
is when you need to send
the body after additional headers
in
the request, but can optionally call endRequest() when
you are fin
ished.
*/
void beginBody();
/** Connect to
the server and start to send a GET request.
@param aURLPath Url to request
@return 0 if successful, else error
*/
int get(const char* aURLPath);
int get(const String& aURLPath);
/** Connect to
the server and start to send a POST request.
@param aURLPath Url to request
@return 0 if successful, else error
*/
int post(const char* aURLPath);
int post(const String& aURLPath);
/** Connect to
the server and send a POST request
with body and content type
@param aURLPath Url to request
@param aContentType Content type of request body
@param aBody Body of
the request
@return 0 if successful, else error
*/
int post(const char* aURLPath, const char* aContentType, const char* aBody);
int post(const String& aURLPath, const String& aContentType, const String& aBody);
int post(const char* aURLPath, const char* aContentType, int aContentLength, const byte aBody[]);
/** Connect to
the server and start to send a PUT request.
@param aURLPath Url to request
@return 0 if successful, else error
*/
int put(const char* aURLPath);
int put(const String& aURLPath);
/** Connect to
the server and send a PUT request
with body and content type
@param aURLPath Url to request
@param aContentType Content type of request body
@param aBody Body of
the request
@return 0 if successful, else error
*/
int put(const char* aURLPath, const char* aContentType, const char* aBody);
int put(const String& aURLPath, const String& aContentType, const String& aBody);
int put(const char* aURLPath, const char* aContentType, int aContentLength, const byte aBody[]);
/** Connect to
the server and start to send a PATCH request.
@param aURLPath Url to request
@return 0 if successful, else error
*/
int patch(const char* aURLPath);
int patch(const String& aURLPath);
/** Connect to
the server and send a PATCH request
with body and content type
@param aURLPath Url to request
@param aContentType Content type of request body
@param aBody Body of
the request
@return 0 if successful, else error
*/
int patch(const char* aURLPath, const char* aContentType, const char* aBody);
int patch(const String& aURLPath, const String& aContentType, const String& aBody);
int patch(const char* aURLPath, const char* aContentType, int aContentLength, const byte aBody[]);
/** Connect to
the server and start to send a DELETE request.
@param aURLPath Url to request
@return 0 if successful, else error
*/
int del(const char* aURLPath);
int del(const String& aURLPath);
/** Connect to
the server and send a DELETE request
with body and content type
@param aURLPath Url to request
@param aContentType Content type of request body
@param aBody Body of
the request
@return 0 if successful, else error
*/
int del(const char* aURLPath, const char* aContentType, const char* aBody);
int del(const String& aURLPath, const String& aContentType, const String& aBody);
int del(const char* aURLPath, const char* aContentType, int aContentLength, const byte aBody[]);
/** Connect to
the server and start to send
the request.
If a body
is provided,
the entire request (including headers and body) will be sent
@param aURLPath Url to request
@param aHttpMethod Type of HTTP request to make, e.g. "GET", "POST", etc.
@param aContentType Content type of request body (optional)
@param aContentLength Length of request body (optional)
@param aBody Body of request (optional)
@return 0 if successful, else error
*/
int startRequest(const char* aURLPath,
const char* aHttpMethod,
const char* aContentType = NULL,
int aContentLength = -1,
const byte aBody[] = NULL);
/** Send an additional header line. Th
is can only be called in between
the
calls to beginRequest and endRequest.
@param aHeader Header line to send, in its entirety (but without
the
trailing CRLF. E.g. "Authorization: Basic YQDDCAIGES"
*/
void sendHeader(const char* aHeader);
void sendHeader(const String& aHeader)
{ sendHeader(aHeader.c_str()); }
/** Send an additional header line. Th
is is an alternate form of
sendHeader() which takes
the header name and content as separate strings.
The call will add
the ": " to separate
the header, so for example, to
send a XXXXXX header call sendHeader("XXXXX", "Something")
@param aHeaderName Type of header being sent
@param aHeaderValue Value for that header
*/
void sendHeader(const char* aHeaderName, const char* aHeaderValue);
void sendHeader(const String& aHeaderName, const String& aHeaderValue)
{ sendHeader(aHeaderName.c_str(), aHeaderValue.c_str()); }
/** Send an additional header line. Th
is is an alternate form of
sendHeader() which takes
the header name and content separately but
where
the value
is provided as an integer.
The call will add
the ": " to separate
the header, so for example, to
send a XXXXXX header call sendHeader("XXXXX", 123)
@param aHeaderName Type of header being sent
@param aHeaderValue Value for that header
*/
void sendHeader(const char* aHeaderName, const int aHeaderValue);
void sendHeader(const String& aHeaderName, const int aHeaderValue)
{ sendHeader(aHeaderName.c_str(), aHeaderValue); }
/** Send a basic au
thentication header. Th
is will encode
the given username
and password, and send
them in suitable header line for doing Basic
Au
thentication.
@param aUser Username for
the authorization
@param aPassword Password for
the user aUser
*/
void sendBasicAuth(const char* aUser, const char* aPassword);
void sendBasicAuth(const String& aUser, const String& aPassword)
{ sendBasicAuth(aUser.c_str(), aPassword.c_str()); }
/** Get
the HTTP status code contained in
the response.
For example, 200 for successful request, 404 for file not found, etc.
*/
int responseStatusCode();
/** Check if a header
is available to be read.
Use readHeaderName() to read header name, and readHeaderValue() to
read
the header value
MUST be called after responseStatusCode() and before contentLength()
*/
bool headerAvailable();
/** Read
the name of
the current response header.
Returns empty string if a header
is not available.
*/
String readHeaderName();
/** Read
the value of
the current response header.
Returns empty string if a header
is not available.
*/
String readHeaderValue();
/** Read
the next character of
the response headers.
Th
is functions in
the same way as read() but to be used when reading
through
the headers. Check whe
ther or not
the end of
the headers has
been reached by calling endOfHeadersReached(), although after that point
th
is will still return data as read() would, but slightly
less efficiently
MUST be called after responseStatusCode() and before contentLength()
@return
The next character of
the response headers
*/
int readHeader();
/** Skip any response headers to get to
the body.
Use th
is if you don't want to do any special processing of
the headers
returned in
the response. You can also use it after you've found all of
the headers you're interested in, and just want to get on with processing
the body.
MUST be called after responseStatusCode()
@return HTTP_SUCCESS if successful, else an error code
*/
int skipResponseHeaders();
/** Test whe
ther all of
the response headers have been consumed.
@return true if we are now processing
the response body, else false
*/
bool endOfHeadersReached();
/** Test whe
ther
the end of
the body has been reached.
Only works if
the Content-Length header was returned by
the server
@return true if we are now at
the end of
the body, else false
*/
bool endOfBodyReached();
virtual bool endOfStream() { return endOfBodyReached(); };
virtual bool completed() { return endOfBodyReached(); };
/** Return
the length of
the body.
Also skips response headers if
they have not been read already
MUST be called after responseStatusCode()
@return Length of
the body, in bytes, or kNoContentLengthHeader if no
Content-Length header was returned by
the server
*/
long contentLength();
/** Returns if
the response body
is chunked
@return true if response body
is chunked, false o
therw
ise
*/
int
isResponseChunked() { return i
IsChunked; }
/** Return
the response body as a String
Also skips response headers if
they have not been read already
MUST be called after responseStatusCode()
@return response body of request as a String
*/
String responseBody();
/** Enables connection keep-alive mode
*/
void connectionKeepAlive();
/** D
isables sending
the default request headers (Host and User Agent)
*/
void noDefaultReques
tHeaders();
// Inherited from Print
// Note: 1st call to
these indicates
the user
is sending
the body, so if need
// Note: be we should fin
ish
the header first
virtual size_t write(uint8_t aByte) { if (
iState < eRequestSent) { fin
ishHeaders(); }; return iClient-> write(aByte); };
virtual size_t write(const uint8_t *aBuffer, size_t aSize) { if (
iState < eRequestSent) { fin
ishHeaders(); }; return iClient->write(aBuffer, aSize); };
// Inherited from Stream
virtual int available();
/** Read
the next byte from
the server.
@return Byte read or -1 if
there are no bytes available.
*/
virtual int read();
virtual int read(uint8_t *buf, size_t size);
virtual int peek() { return iClient->peek(); };
virtual void flush() { 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; };
virtual uint32_t httpWaitForDataDelay() { return iHttpWaitForDataDelay; };
virtual void setHttpWaitForDataDelay(uint32_t delay) { iHttpWaitForDataDelay = delay; };
protected:
/** Reset internal state data back to
the "just initial
ised" state
*/
void resetState();
/** Send
the first part of
the request and
the initial headers.
@param aURLPath Url to request
@param aHttpMethod Type of HTTP request to make, e.g. "GET", "POST", etc.
@return 0 if successful, else error
*/
int sendInitialHeaders(const char* aURLPath,
const char* aHttpMethod);
/* Let
the server know that we've reached
the end of
the headers
*/
void fin
ishHeaders();
/** Reading any pending data from
the client (used in connection keep alive mode)
*/
void flushClientRx();
// Number of mill
iseconds that we wait each time
there
isn't any data
// available to be read (during status code and header processing)
static const int kHttpWaitForDataDelay = 100;
// Number of mill
iseconds that we'll wait in total without receiving any
// data before returning HTTP_ERROR_TIMED_OUT (during status code and header
// processing)
static const int kHttpResponseTimeout = 30*1000;
static const char* kContentLengthPrefix;
static const char* kTransferEncodingChunked;
typedef enum {
eIdle,
eRequestStarted,
eRequestSent,
eReadingStatusCode,
eStatusCodeRead,
eReadingContentLength,
eSkipToEndOfHeader,
eLineStartingCRFound,
eReadingBody,
eReadingChunkLength,
eReadingBodyChunk
} tHttpState;
// Client we're using
Client* iClient;
// Server we are connecting to
const char*
iServerName;
IPAddress
iServerAddress;
// Port of server we are connecting to
uint16_t
iServerPort;
// 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
long 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;
// How far through a Transfer-Encoding chunked header we are
const char* iTransferEncodingChunkedPtr;
// Stores if
the response body
is chunked
bool i
IsChunked;
// Stores
the value of
the current chunk length, if present
int iChunkLength;
uint32_t iHttpResponseTimeout;
uint32_t iHttpWaitForDataDelay;
bool iConnectionClose;
bool
iSendDefaultReques
tHeaders;
String iHeaderLine;
};
#endif
能否基于https://docs.arduino.cc/libraries/e
thernet/#Client%20Class中的E
thernetClient帮我仿照实现下所有对应的功能
本文介绍了解决Solaris系统中ZFS ARC默认设置导致内存占用过高的方法。通过调整ZFS ARC的最大缓存大小，可以为Oracle等应用程序预留足够的内存空间。
扫一扫
860
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
