自学教程：C++ DEBUG_HTTPCLIENT函数代码示例

/** * init TCP connection and handle ssl verify if needed * @return true if connection is ok */bool HTTPClient::connect(void) {    if(connected()) {        DEBUG_HTTPCLIENT("[HTTP-Client] connect. already connected, try reuse!/n");        return true;    }        DEBUG_HTTPCLIENT("[HTTP-Client] connect http.../n");        if(_tcp) {            delete _tcp;            _tcp = NULL;        }        _tcp = new WiFiClient();    if(!_tcp->connect(_host.c_str(), _port)) {        DEBUG_HTTPCLIENT("[HTTP-Client] failed connect to %s:%u/n", _host.c_str(), _port);        return false;    }    DEBUG_HTTPCLIENT("[HTTP-Client] connected to %s:%u/n", _host.c_str(), _port);    // set Timeout for readBytesUntil and readStringUntil    _tcp->setTimeout(_tcpTimeout);#ifdef ESP31B    _tcp->setNoDelay(true);#endif    return connected();}

/** * reads the response from the server * @return int http code */int HTTPClient::handleHeaderResponse() {    if(!connected()) {        return HTTPC_ERROR_NOT_CONNECTED;    }    _returnCode = -1;    _size = -1;    while(connected()) {        size_t len = _tcp->available();        if(len > 0) {            String headerLine = _tcp->readStringUntil('/n');            headerLine.trim(); // remove /r            DEBUG_HTTPCLIENT("[HTTP-Client][handleHeaderResponse] RX: '%s'/n", headerLine.c_str());            if(headerLine.startsWith("HTTP/1.")) {                _returnCode = headerLine.substring(9, headerLine.indexOf(' ', 9)).toInt();            } else if(headerLine.indexOf(':')) {                String headerName = headerLine.substring(0, headerLine.indexOf(':'));                String headerValue = headerLine.substring(headerLine.indexOf(':') + 2);                if(headerName.equalsIgnoreCase("Content-Length")) {                    _size = headerValue.toInt();                }                if(headerName.equalsIgnoreCase("Connection")) {                    _canReuse = headerValue.equalsIgnoreCase("keep-alive");                }                for(size_t i = 0; i < _headerKeysCount; i++) {                    if(_currentHeaders[i].key.equalsIgnoreCase(headerName)) {                        _currentHeaders[i].value = headerValue;                        break;                    }                }            }            if(headerLine == "") {                DEBUG_HTTPCLIENT("[HTTP-Client][handleHeaderResponse] code: %d/n", _returnCode);                if(_size) {                    DEBUG_HTTPCLIENT("[HTTP-Client][handleHeaderResponse] size: %d/n", _size);                }                if(_returnCode) {                    return _returnCode;                } else {                    DEBUG_HTTPCLIENT("[HTTP-Client][handleHeaderResponse] Remote host is not an HTTP Server!");                    return HTTPC_ERROR_NO_HTTP_SERVER;                }            }        } else {            delay(0);        }    }    return HTTPC_ERROR_CONNECTION_LOST;}

/** * phasing the url for all needed informations * @param url String * @param httpsFingerprint String */void HTTPClient::begin(String url, String httpsFingerprint) {    DEBUG_HTTPCLIENT("[HTTP-Client][begin] url: %s/n", url.c_str());    _httpsFingerprint = httpsFingerprint;    _returnCode = 0;    _size = -1;    _Headers = "";    String protocol;    // check for : (http: or https:    int index = url.indexOf(':');    int index2;    bool hasPort = false;    if(index) {        protocol = url.substring(0, index);        url.remove(0, (index + 3)); // remove http:// or https://        index = url.indexOf(':');        index2 = url.indexOf('/');        if(index >= 0 && ((index2 >= 0 && index < index2) || index2 == 0)) { // do we have a port?            _host = url.substring(0, index); // hostname            url.remove(0, (index + 1)); // remove hostname + :            index = url.indexOf('/');            _port = url.substring(0, index).toInt(); // get port            url.remove(0, index); // remove port            hasPort = true;        } else {            index = index2;            _host = url.substring(0, index);            url.remove(0, index); // remove hostname        }        _url = url;        if(protocol.equalsIgnoreCase("http")) {            _https = false;            if(!hasPort) {                _port = 80;            }        } else if(protocol.equalsIgnoreCase("https")) {            _https = true;            if(!hasPort) {                _port = 443;            }        } else {            DEBUG_HTTPCLIENT("[HTTP-Client][begin] protocol: %s unknown?!/n", protocol.c_str());            return;        }    }    DEBUG_HTTPCLIENT("[HTTP-Client][begin] host: %s port: %d url: %s https: %d httpsFingerprint: %s/n", _host.c_str(), _port, _url.c_str(), _https, _httpsFingerprint.c_str());}

bool HTTPClient::beginInternal(String url, const char* expectedProtocol){    DEBUG_HTTPCLIENT("[HTTP-Client][begin] url: %s/n", url.c_str());    bool hasPort = false;    clear();    // check for : (http: or https:    int index = url.indexOf(':');    if(index < 0) {        DEBUG_HTTPCLIENT("[HTTP-Client][begin] failed to parse protocol/n");        return false;    }    _protocol = url.substring(0, index);    url.remove(0, (index + 3)); // remove http:// or https://    index = url.indexOf('/');    String host = url.substring(0, index);    url.remove(0, index); // remove host part    // get Authorization    index = host.indexOf('@');    if(index >= 0) {        // auth info        String auth = host.substring(0, index);        host.remove(0, index + 1); // remove auth part including @        _base64Authorization = base64::encode(auth);    }    // get port    index = host.indexOf(':');    if(index >= 0) {        _host = host.substring(0, index); // hostname        host.remove(0, (index + 1)); // remove hostname + :        _port = host.toInt(); // get port    } else {        _host = host;    }    _uri = url;    if (_protocol != expectedProtocol) {        DEBUG_HTTPCLIENT("[HTTP-Client][begin] unexpected protocol: %s, expected %s/n", _protocol.c_str(), expectedProtocol);        return false;    }    DEBUG_HTTPCLIENT("[HTTP-Client][begin] host: %s port: %d url: %s/n", _host.c_str(), _port, _uri.c_str());    return true;}

/** * end * called after the payload is handled */void HTTPClient::end(void) {    if(connected()) {        if(_tcp->available() > 0) {            DEBUG_HTTPCLIENT("[HTTP-Client][end] still data in buffer (%d), clean up./n", _tcp->available());            while(_tcp->available() > 0) {                _tcp->read();            }        }        if(_reuse && _canReuse) {            DEBUG_HTTPCLIENT("[HTTP-Client][end] tcp keep open for reuse/n");        } else {            DEBUG_HTTPCLIENT("[HTTP-Client][end] tcp stop/n");            _tcp->stop();        }    } else {        DEBUG_HTTPCLIENT("[HTTP-Client][end] tcp is closed/n");    }}

bool HTTPClient::begin(String host, uint16_t port, String uri){    clear();    _host = host;    _port = port;    _uri = uri;    _transportTraits = TransportTraitsPtr(new TransportTraits());    DEBUG_HTTPCLIENT("[HTTP-Client][begin] host: %s port: %d uri: %s/n", host.c_str(), port, uri.c_str());    return true;}

/** * init TCP connection and handle ssl verify if needed * @return true if connection is ok */bool HTTPClient::connect(void) {    if(connected()) {        DEBUG_HTTPCLIENT("[HTTP-Client] connect. already connected, try reuse!/n");        return true;    }#ifndef DISABLE_SSL    if(_https) {        DEBUG_HTTPCLIENT("[HTTP-Client] connect https.../n");        if(_tcps) {            delete _tcps;            _tcps = NULL;            _tcp = NULL;        }        _tcps = new WiFiClientSecure();        _tcp = _tcps;    } else {#endif /* DISABLE_SSL */        DEBUG_HTTPCLIENT("[HTTP-Client] connect http.../n");        if(_tcp) {            delete _tcp;            _tcp = NULL;        }        _tcp = new WiFiClient();#ifndef DISABLE_SSL    }#endif /* DISABLE_SSL */    if(!_tcp->connect(_host.c_str(), _port)) {        DEBUG_HTTPCLIENT("[HTTP-Client] failed connect to %s:%u/n", _host.c_str(), _port);        return false;    }    DEBUG_HTTPCLIENT("[HTTP-Client] connected to %s:%u/n", _host.c_str(), _port);#ifndef DISABLE_SSL    if(_https && _httpsFingerprint.length() > 0) {        if(_tcps->verify(_httpsFingerprint.c_str(), _host.c_str())) {            DEBUG_HTTPCLIENT("[HTTP-Client] https certificate matches/n");        } else {            DEBUG_HTTPCLIENT("[HTTP-Client] https certificate doesn't match!/n");            _tcp->stop();            return false;        }    }#endif /* DISABLE_SSL */    // set Timeout for readBytesUntil and readStringUntil    _tcp->setTimeout(_tcpTimeout);#ifdef ESP8266    _tcp->setNoDelay(true);#endif    return connected();}

bool HTTPClient::begin(String url, String httpsFingerprint){    _transportTraits.reset(nullptr);    if (httpsFingerprint.length() == 0) {        return false;    }    if (!beginInternal(url, "https")) {        return false;    }    _transportTraits = TransportTraitsPtr(new TLSTraits(httpsFingerprint));    DEBUG_HTTPCLIENT("[HTTP-Client][begin] httpsFingerprint: %s/n", httpsFingerprint.c_str());    return true;}

/** * sends HTTP request header * @param type (GET, POST, ...) * @return status */bool HTTPClient::sendHeader(const char * type){    if(!connected()) {        return false;    }    String header = String(type) + " " + (_uri.length() ? _uri : F("/")) + F(" HTTP/1.");    if(_useHTTP10) {        header += "0";    } else {        header += "1";    }    header += String(F("/r/nHost: ")) + _host;    if (_port != 80 && _port != 443)    {        header += ':';        header += String(_port);    }    header += String(F("/r/nUser-Agent: ")) + _userAgent +              F("/r/nConnection: ");    if(_reuse) {        header += F("keep-alive");    } else {        header += F("close");    }    header += "/r/n";    if(!_useHTTP10) {        header += F("Accept-Encoding: identity;q=1,chunked;q=0.1,*;q=0/r/n");    }    if(_base64Authorization.length()) {        _base64Authorization.replace("/n", "");        header += F("Authorization: Basic ");        header += _base64Authorization;        header += "/r/n";    }    header += _headers + "/r/n";    DEBUG_HTTPCLIENT("[HTTP-Client] sending request header/n-----/n%s-----/n", header.c_str());    return (_tcp->write((const uint8_t *) header.c_str(), header.length()) == header.length());}

/** * write one Data Block to Stream * @param stream Stream * * @param size int * @return < 0 = error >= 0 = size written */int HTTPClient::writeToStreamDataBlock(Stream * stream, int size) {    int buff_size = HTTP_TCP_BUFFER_SIZE;    int len = size;    int bytesWritten = 0;    // if possible create smaller buffer then HTTP_TCP_BUFFER_SIZE    if((len > 0) && (len < HTTP_TCP_BUFFER_SIZE)) {        buff_size = len;    }    // create buffer for read    uint8_t * buff = (uint8_t *) malloc(buff_size);    if(buff) {        // read all data from server        while(connected() && (len > 0 || len == -1)) {            // get available data size            size_t sizeAvailable = _tcp->available();            if(sizeAvailable) {                int readBytes = sizeAvailable;                // read only the asked bytes                if(len > 0 && readBytes > len) {                    readBytes = len;                }                // not read more the buffer can handle                if(readBytes > buff_size) {                    readBytes = buff_size;                }                // read data                int bytesRead = _tcp->readBytes(buff, readBytes);                // write it to Stream                int bytesWrite = stream->write(buff, bytesRead);                bytesWritten += bytesWrite;                // are all Bytes a writen to stream ?                if(bytesWrite != bytesRead) {                    DEBUG_HTTPCLIENT("[HTTP-Client][writeToStream] short write asked for %d but got %d retry.../n", bytesRead, bytesWrite);                    // check for write error                    if(stream->getWriteError()) {                        DEBUG_HTTPCLIENT("[HTTP-Client][writeToStreamDataBlock] stream write error %d/n", stream->getWriteError());                        //reset write error for retry                        stream->clearWriteError();                    }                    // some time for the stream                    delay(1);                    int leftBytes = (readBytes - bytesWrite);                    // retry to send the missed bytes                    bytesWrite = stream->write((buff + bytesWrite), leftBytes);                    bytesWritten += bytesWrite;                    if(bytesWrite != leftBytes) {                        // failed again                        DEBUG_HTTPCLIENT("[HTTP-Client][writeToStream] short write asked for %d but got %d failed./n", leftBytes, bytesWrite);                        free(buff);                        return HTTPC_ERROR_STREAM_WRITE;                    }                }                // check for write error                if(stream->getWriteError()) {                    DEBUG_HTTPCLIENT("[HTTP-Client][writeToStreamDataBlock] stream write error %d/n", stream->getWriteError());                    free(buff);                    return HTTPC_ERROR_STREAM_WRITE;                }                // count bytes to read left                if(len > 0) {                    len -= readBytes;                }                delay(0);            } else {                delay(1);            }        }        free(buff);        DEBUG_HTTPCLIENT("[HTTP-Client][writeToStreamDataBlock] connection closed or file end (written: %d)./n", bytesWritten);        if((size > 0) && (size != bytesWritten)) {            DEBUG_HTTPCLIENT("[HTTP-Client][writeToStreamDataBlock] bytesWritten %d and size %d mismatch!./n", bytesWritten, size);//.........这里部分代码省略.........

/** * write all  message body / payload to Stream * @param stream Stream * * @return bytes written ( negative values are error codes ) */int HTTPClient::writeToStream(Stream * stream) {    if(!stream) {        return returnError(HTTPC_ERROR_NO_STREAM);    }    if(!connected()) {        return returnError(HTTPC_ERROR_NOT_CONNECTED);    }    // get length of document (is -1 when Server sends no Content-Length header)    int len = _size;    int ret = 0;    if(_transferEncoding == HTTPC_TE_IDENTITY) {        ret = writeToStreamDataBlock(stream, len);        // have we an error?        if(ret < 0) {            return returnError(ret);        }    } else if(_transferEncoding == HTTPC_TE_CHUNKED) {        int size = 0;        while(1) {            if(!connected()) {                return returnError(HTTPC_ERROR_CONNECTION_LOST);            }            String chunkHeader = _tcp->readStringUntil('/n');            if(chunkHeader.length() <= 0) {                return returnError(HTTPC_ERROR_READ_TIMEOUT);            }            chunkHeader.trim(); // remove /r            // read size of chunk            len = (uint32_t) strtol((const char *) chunkHeader.c_str(), NULL, 16);            size += len;            DEBUG_HTTPCLIENT("[HTTP-Client] read chunk len: %d/n", len);            // data left?            if(len > 0) {                int r = writeToStreamDataBlock(stream, len);                if(r < 0) {                    // error in writeToStreamDataBlock                    return returnError(r);                }                ret += r;            } else {                // if no length Header use global chunk size                if(_size <= 0) {                    _size = size;                }                // check if we have write all data out                if(ret != _size) {                    return returnError(HTTPC_ERROR_STREAM_WRITE);                }                break;            }            delay(0);        }    } else {        return returnError(HTTPC_ERROR_ENCODING);    }    end();    return ret;}

/** * sendRequest * @param type const char *     "GET", "POST", .... * @param stream Stream *       data stream for the message body * @param size size_t           size for the message body if 0 not Content-Length is send * @return -1 if no info or > 0 when Content-Length is set by server */int HTTPClient::sendRequest(const char * type, Stream * stream, size_t size) {    if(!stream) {        return HTTPC_ERROR_NO_STREAM;    }    // connect to server    if(!connect()) {        return HTTPC_ERROR_CONNECTION_REFUSED;    }    if(size > 0) {        addHeader("Content-Length", String(size));    }    // send Header    if(!sendHeader(type)) {        return HTTPC_ERROR_SEND_HEADER_FAILED;    }    // create buffer for read    uint8_t buff[1460] = { 0 };    int len = size;    int bytesWritten = 0;    if(len == 0) {        len = -1;    }    // read all data from stream and send it to server    while(connected() && stream->available() && (len > 0 || len == -1)) {        // get available data size        size_t s = stream->available();        if(s) {            int c = stream->readBytes(buff, ((s > sizeof(buff)) ? sizeof(buff) : s));            // write it to Stream            bytesWritten += _tcp->write((const uint8_t *)buff, c);            if(len > 0) {                len -= c;            }            delay(0);        } else {            delay(1);        }    }    if(size && (int)size != bytesWritten) {        DEBUG_HTTPCLIENT("[HTTP-Client][sendRequest] Stream payload bytesWritten %d and size %d mismatch!./n", bytesWritten, _size);        DEBUG_HTTPCLIENT("[HTTP-Client][sendRequest] ERROR SEND PAYLOAD FAILED!");        return HTTPC_ERROR_SEND_PAYLOAD_FAILED;    } else {        DEBUG_HTTPCLIENT("[HTTP-Client][sendRequest] Stream payload written: %d/n", bytesWritten);    }    // handle Server Response (Header)    return handleHeaderResponse();}

/** * reads the response from the server * @return int http code */int HTTPClient::handleHeaderResponse(){    if(!connected()) {        return HTTPC_ERROR_NOT_CONNECTED;    }    String transferEncoding;    _returnCode = -1;    _size = -1;    _transferEncoding = HTTPC_TE_IDENTITY;    unsigned long lastDataTime = millis();    while(connected()) {        size_t len = _tcp->available();        if(len > 0) {            String headerLine = _tcp->readStringUntil('/n');            headerLine.trim(); // remove /r            lastDataTime = millis();            DEBUG_HTTPCLIENT("[HTTP-Client][handleHeaderResponse] RX: '%s'/n", headerLine.c_str());            if(headerLine.startsWith("HTTP/1.")) {                _returnCode = headerLine.substring(9, headerLine.indexOf(' ', 9)).toInt();            } else if(headerLine.indexOf(':')) {                String headerName = headerLine.substring(0, headerLine.indexOf(':'));                String headerValue = headerLine.substring(headerLine.indexOf(':') + 2);                if(headerName.equalsIgnoreCase("Content-Length")) {                    _size = headerValue.toInt();                }                if(headerName.equalsIgnoreCase("Connection")) {                    _canReuse = headerValue.equalsIgnoreCase("keep-alive");                }                if(headerName.equalsIgnoreCase("Transfer-Encoding")) {                    transferEncoding = headerValue;                }                for(size_t i = 0; i < _headerKeysCount; i++) {                    if(_currentHeaders[i].key.equalsIgnoreCase(headerName)) {                        _currentHeaders[i].value = headerValue;                        break;                    }                }            }            if(headerLine == "") {                DEBUG_HTTPCLIENT("[HTTP-Client][handleHeaderResponse] code: %d/n", _returnCode);                if(_size > 0) {                    DEBUG_HTTPCLIENT("[HTTP-Client][handleHeaderResponse] size: %d/n", _size);                }                if(transferEncoding.length() > 0) {                    DEBUG_HTTPCLIENT("[HTTP-Client][handleHeaderResponse] Transfer-Encoding: %s/n", transferEncoding.c_str());                    if(transferEncoding.equalsIgnoreCase("chunked")) {                        _transferEncoding = HTTPC_TE_CHUNKED;                    } else {                        return HTTPC_ERROR_ENCODING;                    }                } else {                    _transferEncoding = HTTPC_TE_IDENTITY;                }                if(_returnCode) {                    return _returnCode;                } else {                    DEBUG_HTTPCLIENT("[HTTP-Client][handleHeaderResponse] Remote host is not an HTTP Server!");                    return HTTPC_ERROR_NO_HTTP_SERVER;                }            }        } else {            if((millis() - lastDataTime) > _tcpTimeout) {                return HTTPC_ERROR_READ_TIMEOUT;            }            delay(0);        }    }    return HTTPC_ERROR_CONNECTION_LOST;}