libcurl యొక్క బైనరీ ప్రతిస్పందనలను C++ std::string లోకి స్వీకరించడం

ఒక ప్రాక్సీ HTML ను విజయవంతంగా పొందగలదు మరియు ఒక చిత్రాన్ని C++ బఫర్‌లోకి కాపీ చేసేటప్పుడు దాన్ని పాడు చేయగలదు. ప్రాక్సీ ప్రోటోకాల్‌ను మార్చే ముందు, స్వీకరణ callback మరియు దాని context గా పంపిన వస్తువును తనిఖీ చేయండి.

CURLOPT_WRITEDATA రైట్ callback కు పాయింటర్‌ను అందిస్తుంది. అనుకూల callback లేకుండా, libcurl యొక్క డిఫాల్ట్ రైటర్ FILE * ను ఆశిస్తుంది. &response వంటి చిరునామా, ఇక్కడ response ఒక std::string, మీ callback ఆ context ను ఉద్దేశించిన రకంలోకి తిరిగి మార్చినప్పుడు మాత్రమే అర్థవంతం.

static size_t receive(char* data, size_t size,
                      size_t count, void* context) {
    const size_t bytes = size * count;
    auto* body = static_cast<std::string*>(context);
    try {
        body->append(data, bytes);
    } catch (...) {
        return 0;
    }
    return bytes;
}

రెండు భాగాలను బదిలీ కోసం ఉపయోగించే సరళమైన హ్యాండిల్‌పై నమోదు చేయండి:

std::string response;
curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, receive);
curl_easy_setopt(handle, CURLOPT_WRITEDATA, &response);

append కాల్ ఇచ్చిన బైట్ గణనను ఉపయోగిస్తుంది. callback డేటా null-terminated కాదు, మరియు చిత్రంలో సున్నా బైట్లు ఉండవచ్చు; strlen తో కొలిస్తే శరీరంలో కొంత భాగం పోతుంది. ప్రతిస్పందన వివిధ పరిమాణాల అనేక callback కాల్స్ ద్వారా కూడా రావచ్చు.

వినియోగించిన బైట్ గణనను తిరిగి ఇవ్వడం ఆ ముక్కను అంగీకరిస్తుంది. వేరే గణనను తిరిగి ఇవ్వడం రైటింగ్ లోపంతో బదిలీని ఆపివేస్తుంది. మినహాయింపు కాపలాదారు కేటాయింపు వైఫల్యం C callback సరిహద్దు నుండి బయటపడకుండా నిరోధిస్తుంది; కాలర్ response ను పూర్తి ఫైల్‌గా పరిగణించే ముందు బదిలీ ఫలితాన్ని ఇంకా తనిఖీ చేయాలి.

బదిలీ పూర్తయ్యే వరకు స్ట్రింగ్‌ను సజీవంగా ఉంచండి. అసమకాలిక సాకెట్ రైటింగ్ తర్వాత దాని కంటెంట్‌ను పంపితే, ఆ రైటింగ్ కూడా పూర్తయ్యే వరకు ఆ బైట్లను సజీవంగా ఉంచండి. పెద్ద ప్రతిస్పందనల కోసం, మొత్తం శరీరాన్ని సేకరించడం కంటే పరిమిత స్ట్రీమింగ్ ఏర్పాటు మంచిది.