libcurl හි ද්විමය ප්‍රතිචාර C++ std::string එකකට ලබා ගැනීම

std::string එකක් callback context ලෙස යවා libcurl සමඟ ද්විමය දත්ත ලබා ගන්නා විට පැහැදිලි byte ගණනයන් එකතු කරන්න.

proxy එකකට HTML සාර්ථකව ලබා ගත හැකි වුවත් රූපයක් C++ buffer එකකට පිටපත් කරන විට එය විනාශ කළ හැකිය. proxy protocol එක වෙනස් කිරීමට පෙර, ලබා ගැනීමේ callback එක සහ එහි context ලෙස යවන වස්තුව පරීක්ෂා කරන්න.

CURLOPT_WRITEDATA ලිවීමේ callback එකට pointer එකක් සපයයි. අභිරුචි 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 ඇමතුම ලබා දුන් byte ගණන භාවිතා කරයි. callback දත්ත null-terminated නොවන අතර රූපයක ශුන්‍ය byte තිබිය හැකිය; strlen සමඟ මැනීමෙන් ශරීරයේ කොටසක් අහිමි වේ. ප්‍රතිචාරයක් විවිධ ප්‍රමාණවල බොහෝ callback ඇමතුම් හරහා ද පැමිණිය හැකිය.

පරිභෝජනය කළ byte ගණන ආපසු දීමෙන් කොටස පිළිගනු ලැබේ. වෙනස් ගණනක් ආපසු දීමෙන් ලිවීමේ දෝෂයක් සමඟ ස්ථාන මාරුව නතර වේ. ව්‍යතිරේක ආරක්ෂකය වෙන් කිරීමේ අසාර්ථකත්වයක් C callback සීමාවෙන් පිටතට යාම වළක්වයි; ඇමතුම්කරු response එක සම්පූර්ණ ගොනුවක් ලෙස සැලකීමට පෙර ස්ථාන මාරු ප්‍රතිඵලය තවමත් පරීක්ෂා කළ යුතුය.

ස්ථාන මාරුව අවසන් වන තෙක් string එක ජීවමානව තබන්න. අසමමුහුර්ත socket ලිවීමක් පසුව එහි අන්තර්ගතය ඉදිරියට යවන්නේ නම්, එම ලිවීම ද අවසන් වන තෙක් එම byte ජීවමානව තබන්න. විශාල ප්‍රතිචාර සඳහා, මුළු ශරීරයම එකතු කිරීමට වඩා සීමිත streaming විධිවිධානය වඩාත් සුදුසුය.

අදාළ ලිපි